src/atimer.c

   1 /* Asynchronous timers.
   2    Copyright (C) 2000-2018 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 3 of the License, or (at
   9 your option) 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.  If not, see <https://www.gnu.org/licenses/>.  */
  18
  19 #include <config.h>
  20 #include <stdio.h>
  21
  22 #include "lisp.h"
  23 #include "keyboard.h"
  24 #include "syssignal.h"
  25 #include "systime.h"
  26 #include "atimer.h"
  27 #include <unistd.h>
  28
  29 #ifdef HAVE_TIMERFD
  30 #include <errno.h>
  31 # include <sys/timerfd.h>
  32 #endif
  33
  34 #ifdef MSDOS
  35 #include "msdos.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 #ifdef HAVE_ITIMERSPEC
  53 /* The alarm timer and whether it was properly initialized, if
  54    POSIX timers are available.  */
  55 static timer_t alarm_timer;
  56 static bool alarm_timer_ok;
  57
  58 # ifdef HAVE_TIMERFD
  59 /* File descriptor for timer, or -1 if it could not be created.  */
  60 static int timerfd;
  61 # else
  62 enum { timerfd = -1 };
  63 # endif
  64 #endif
  65
  66 /* Block/unblock SIGALRM.  */
  67
  68 static void
  69 block_atimers (sigset_t *oldset)
  70 {
  71   sigset_t blocked;
  72   sigemptyset (&blocked);
  73   sigaddset (&blocked, SIGALRM);
  74   sigaddset (&blocked, SIGINT);
  75   pthread_sigmask (SIG_BLOCK, &blocked, oldset);
  76 }
  77 static void
  78 unblock_atimers (sigset_t const *oldset)
  79 {
  80   pthread_sigmask (SIG_SETMASK, oldset, 0);
  81 }
  82
  83 /* Function prototypes.  */
  84
  85 static void set_alarm (void);
  86 static void schedule_atimer (struct atimer *);
  87 static struct atimer *append_atimer_lists (struct atimer *,
  88                                            struct atimer *);
  89
  90 /* Start a new atimer of type TYPE.  TIMESTAMP specifies when the timer is
  91    ripe.  FN is the function to call when the timer fires.
  92    CLIENT_DATA is stored in the client_data member of the atimer
  93    structure returned and so made available to FN when it is called.
  94
  95    If TYPE is ATIMER_ABSOLUTE, TIMESTAMP is the absolute time at which the
  96    timer fires.
  97
  98    If TYPE is ATIMER_RELATIVE, the timer is ripe TIMESTAMP seconds in the
  99    future.
 100
 101    In both cases, the timer is automatically freed after it has fired.
 102
 103    If TYPE is ATIMER_CONTINUOUS, the timer fires every TIMESTAMP seconds.
 104
 105    Value is a pointer to the atimer started.  It can be used in calls
 106    to cancel_atimer; don't free it yourself.  */
 107
 108 struct atimer *
 109 start_atimer (enum atimer_type type, struct timespec timestamp,
 110               atimer_callback fn, void *client_data)
 111 {
 112   struct atimer *t;
 113   sigset_t oldset;
 114
 115   /* Round TIMESTAMP up to the next full second if we don't have itimers.  */
 116 #ifndef HAVE_SETITIMER
 117   if (timestamp.tv_nsec != 0 && timestamp.tv_sec < TYPE_MAXIMUM (time_t))
 118     timestamp = make_timespec (timestamp.tv_sec + 1, 0);
 119 #endif /* not HAVE_SETITIMER */
 120
 121   /* Get an atimer structure from the free-list, or allocate
 122      a new one.  */
 123   if (free_atimers)
 124     {
 125       t = free_atimers;
 126       free_atimers = t->next;
 127     }
 128   else
 129     t = xmalloc (sizeof *t);
 130
 131   /* Fill the atimer structure.  */
 132   memset (t, 0, sizeof *t);
 133   t->type = type;
 134   t->fn = fn;
 135   t->client_data = client_data;
 136
 137   block_atimers (&oldset);
 138
 139   /* Compute the timer's expiration time.  */
 140   switch (type)
 141     {
 142     case ATIMER_ABSOLUTE:
 143       t->expiration = timestamp;
 144       break;
 145
 146     case ATIMER_RELATIVE:
 147       t->expiration = timespec_add (current_timespec (), timestamp);
 148       break;
 149
 150     case ATIMER_CONTINUOUS:
 151       t->expiration = timespec_add (current_timespec (), timestamp);
 152       t->interval = timestamp;
 153       break;
 154     }
 155
 156   /* Insert the timer in the list of active atimers.  */
 157   schedule_atimer (t);
 158   unblock_atimers (&oldset);
 159
 160   /* Arrange for a SIGALRM at the time the next atimer is ripe.  */
 161   set_alarm ();
 162
 163   return t;
 164 }
 165
 166
 167 /* Cancel and free atimer TIMER.  */
 168
 169 void
 170 cancel_atimer (struct atimer *timer)
 171 {
 172   int i;
 173   sigset_t oldset;
 174
 175   block_atimers (&oldset);
 176
 177   for (i = 0; i < 2; ++i)
 178     {
 179       struct atimer *t, *prev;
 180       struct atimer **list = i ? &stopped_atimers : &atimers;
 181
 182       /* See if TIMER is active or stopped.  */
 183       for (t = *list, prev = NULL; t && t != timer; prev = t, t = t->next)
 184         ;
 185
 186       /* If it is, take it off its list, and put in on the free-list.
 187          We don't bother to arrange for setting a different alarm time,
 188          since a too early one doesn't hurt.  */
 189       if (t)
 190         {
 191           if (prev)
 192             prev->next = t->next;
 193           else
 194             *list = t->next;
 195
 196           t->next = free_atimers;
 197           free_atimers = t;
 198           break;
 199         }
 200     }
 201
 202   unblock_atimers (&oldset);
 203 }
 204
 205
 206 /* Append two lists of atimers LIST_1 and LIST_2 and return the
 207    result list.  */
 208
 209 static struct atimer *
 210 append_atimer_lists (struct atimer *list_1, struct atimer *list_2)
 211 {
 212   if (list_1 == NULL)
 213     return list_2;
 214   else if (list_2 == NULL)
 215     return list_1;
 216   else
 217     {
 218       struct atimer *p;
 219
 220       for (p = list_1; p->next; p = p->next)
 221         ;
 222       p->next = list_2;
 223       return list_1;
 224     }
 225 }
 226
 227
 228 /* Stop all timers except timer T.  T null means stop all timers.  */
 229
 230 void
 231 stop_other_atimers (struct atimer *t)
 232 {
 233   sigset_t oldset;
 234   block_atimers (&oldset);
 235
 236   if (t)
 237     {
 238       struct atimer *p, *prev;
 239
 240       /* See if T is active.  */
 241       for (p = atimers, prev = NULL; p && p != t; prev = p, p = p->next)
 242         ;
 243
 244       if (p == t)
 245         {
 246           if (prev)
 247             prev->next = t->next;
 248           else
 249             atimers = t->next;
 250           t->next = NULL;
 251         }
 252       else
 253         /* T is not active.  Let's handle this like T == 0.  */
 254         t = NULL;
 255     }
 256
 257   stopped_atimers = append_atimer_lists (atimers, stopped_atimers);
 258   atimers = t;
 259   unblock_atimers (&oldset);
 260 }
 261
 262
 263 /* Run all timers again, if some have been stopped with a call to
 264    stop_other_atimers.  */
 265
 266 void
 267 run_all_atimers (void)
 268 {
 269   if (stopped_atimers)
 270     {
 271       struct atimer *t = atimers;
 272       struct atimer *next;
 273       sigset_t oldset;
 274
 275       block_atimers (&oldset);
 276       atimers = stopped_atimers;
 277       stopped_atimers = NULL;
 278
 279       while (t)
 280         {
 281           next = t->next;
 282           schedule_atimer (t);
 283           t = next;
 284         }
 285
 286       unblock_atimers (&oldset);
 287     }
 288 }
 289
 290
 291 /* Arrange for a SIGALRM to arrive when the next timer is ripe.  */
 292
 293 static void
 294 set_alarm (void)
 295 {
 296   if (atimers)
 297     {
 298 #ifdef HAVE_SETITIMER
 299       struct itimerval it;
 300 #endif
 301       struct timespec now, interval;
 302
 303 #ifdef HAVE_ITIMERSPEC
 304       if (0 <= timerfd || alarm_timer_ok)
 305         {
 306           struct itimerspec ispec;
 307           ispec.it_value = atimers->expiration;
 308           ispec.it_interval.tv_sec = ispec.it_interval.tv_nsec = 0;
 309 # ifdef HAVE_TIMERFD
 310           if (timerfd_settime (timerfd, TFD_TIMER_ABSTIME, &ispec, 0) == 0)
 311             {
 312               add_timer_wait_descriptor (timerfd);
 313               return;
 314             }
 315 # endif
 316           if (alarm_timer_ok
 317               && timer_settime (alarm_timer, TIMER_ABSTIME, &ispec, 0) == 0)
 318             return;
 319         }
 320 #endif
 321
 322       /* Determine interval till the next timer is ripe.
 323          Don't set the interval to 0; this disables the timer.  */
 324       now = current_timespec ();
 325       interval = (timespec_cmp (atimers->expiration, now) <= 0
 326                   ? make_timespec (0, 1000 * 1000)
 327                   : timespec_sub (atimers->expiration, now));
 328
 329 #ifdef HAVE_SETITIMER
 330
 331       memset (&it, 0, sizeof it);
 332       it.it_value = make_timeval (interval);
 333       setitimer (ITIMER_REAL, &it, 0);
 334 #else /* not HAVE_SETITIMER */
 335       alarm (max (interval.tv_sec, 1));
 336 #endif /* not HAVE_SETITIMER */
 337     }
 338 }
 339
 340
 341 /* Insert timer T into the list of active atimers `atimers', keeping
 342    the list sorted by expiration time.  T must not be in this list
 343    already.  */
 344
 345 static void
 346 schedule_atimer (struct atimer *t)
 347 {
 348   struct atimer *a = atimers, *prev = NULL;
 349
 350   /* Look for the first atimer that is ripe after T.  */
 351   while (a && timespec_cmp (a->expiration, t->expiration) < 0)
 352     prev = a, a = a->next;
 353
 354   /* Insert T in front of the atimer found, if any.  */
 355   if (prev)
 356     prev->next = t;
 357   else
 358     atimers = t;
 359
 360   t->next = a;
 361 }
 362
 363 static void
 364 run_timers (void)
 365 {
 366   struct timespec now = current_timespec ();
 367
 368   while (atimers && timespec_cmp (atimers->expiration, now) <= 0)
 369     {
 370       struct atimer *t = atimers;
 371       atimers = atimers->next;
 372       t->fn (t);
 373
 374       if (t->type == ATIMER_CONTINUOUS)
 375         {
 376           t->expiration = timespec_add (now, t->interval);
 377           schedule_atimer (t);
 378         }
 379       else
 380         {
 381           t->next = free_atimers;
 382           free_atimers = t;
 383         }
 384     }
 385
 386   set_alarm ();
 387 }
 388
 389
 390 /* Signal handler for SIGALRM.  SIGNO is the signal number, i.e.
 391    SIGALRM.  */
 392
 393 static void
 394 handle_alarm_signal (int sig)
 395 {
 396   pending_signals = 1;
 397 }
 398
 399 #ifdef HAVE_TIMERFD
 400
 401 /* Called from wait_reading_process_output when FD, which
 402    should be equal to TIMERFD, is available for reading.  */
 403
 404 void
 405 timerfd_callback (int fd, void *arg)
 406 {
 407   ptrdiff_t nbytes;
 408   uint64_t expirations;
 409
 410   eassert (fd == timerfd);
 411   nbytes = emacs_read (fd, &expirations, sizeof (expirations));
 412
 413   if (nbytes == sizeof (expirations))
 414     {
 415       /* Timer should expire just once.  */
 416       eassert (expirations == 1);
 417       do_pending_atimers ();
 418     }
 419   else if (nbytes < 0)
 420     /* For some not yet known reason, we may get weird event and no
 421        data on timer descriptor.  This can break Gnus at least, see:
 422        https://lists.gnu.org/r/emacs-devel/2014-07/msg00503.html.  */
 423     eassert (errno == EAGAIN);
 424   else
 425     /* I don't know what else can happen with this descriptor.  */
 426     emacs_abort ();
 427 }
 428
 429 #endif /* HAVE_TIMERFD */
 430
 431 /* Do pending timers.  */
 432
 433 void
 434 do_pending_atimers (void)
 435 {
 436   if (atimers)
 437     {
 438       sigset_t oldset;
 439       block_atimers (&oldset);
 440       run_timers ();
 441       unblock_atimers (&oldset);
 442     }
 443 }
 444
 445
 446 /* Turn alarms on/off.  This seems to be temporarily necessary on
 447    some systems like HPUX (see process.c).  */
 448
 449 void
 450 turn_on_atimers (bool on)
 451 {
 452   if (on)
 453     set_alarm ();
 454   else
 455     {
 456 #ifdef HAVE_ITIMERSPEC
 457       struct itimerspec ispec;
 458       memset (&ispec, 0, sizeof ispec);
 459       if (alarm_timer_ok)
 460         timer_settime (alarm_timer, TIMER_ABSTIME, &ispec, 0);
 461 # ifdef HAVE_TIMERFD
 462       timerfd_settime (timerfd, TFD_TIMER_ABSTIME, &ispec, 0);
 463 # endif
 464 #endif
 465       alarm (0);
 466     }
 467 }
 468
 469 /* This is intended to use from automated tests.  */
 470
 471 #ifdef ENABLE_CHECKING
 472
 473 #define MAXTIMERS 10
 474
 475 struct atimer_result
 476 {
 477   /* Time when we expect this timer to trigger.  */
 478   struct timespec expected;
 479
 480   /* Timer status: -1 if not triggered, 0 if triggered
 481      too early or too late, 1 if triggered timely.  */
 482   int intime;
 483 };
 484
 485 static void
 486 debug_timer_callback (struct atimer *t)
 487 {
 488   struct timespec now = current_timespec ();
 489   struct atimer_result *r = (struct atimer_result *) t->client_data;
 490   int result = timespec_cmp (now, r->expected);
 491
 492   if (result < 0)
 493     /* Too early.  */
 494     r->intime = 0;
 495   else if (result >= 0)
 496     {
 497 #ifdef HAVE_SETITIMER
 498       struct timespec delta = timespec_sub (now, r->expected);
 499       /* Too late if later than expected + 0.02s.  FIXME:
 500          this should depend from system clock resolution.  */
 501       if (timespec_cmp (delta, make_timespec (0, 20000000)) > 0)
 502         r->intime = 0;
 503       else
 504 #endif /* HAVE_SETITIMER */
 505         r->intime = 1;
 506     }
 507 }
 508
 509 DEFUN ("debug-timer-check", Fdebug_timer_check, Sdebug_timer_check, 0, 0, 0,
 510        doc: /* Run internal self-tests to check timers subsystem.
 511 Return t if all self-tests are passed, nil otherwise.  */)
 512   (void)
 513 {
 514   int i, ok;
 515   struct atimer *timer;
 516   struct atimer_result *results[MAXTIMERS];
 517   struct timespec t = make_timespec (0, 0);
 518
 519   /* Arm MAXTIMERS relative timers to trigger with 0.1s intervals.  */
 520   for (i = 0; i < MAXTIMERS; i++)
 521     {
 522       results[i] = xmalloc (sizeof (struct atimer_result));
 523       t = timespec_add (t, make_timespec (0, 100000000));
 524       results[i]->expected = timespec_add (current_timespec (), t);
 525       results[i]->intime = -1;
 526       timer = start_atimer (ATIMER_RELATIVE, t,
 527                             debug_timer_callback, results[i]);
 528     }
 529
 530 #ifdef HAVE_TIMERFD
 531   /* Wait for 1s but process timers.  */
 532   wait_reading_process_output (1, 0, 0, false, Qnil, NULL, 0);
 533 #else
 534   /* If timerfd is not supported, wait_reading_process_output won't
 535      pay attention to timers that expired, and the callbacks won't be
 536      called.  So we need to run the expired timers' callbacks by
 537      hand.  */
 538   /* Wait 1.2 sec for the timers to expire.  */
 539   struct timespec tend =
 540     timespec_add (current_timespec (), make_timespec (1, 200000000));
 541
 542   while (timespec_cmp (current_timespec (), tend) < 0)
 543     {
 544       /* Wait for 5 msec between iterations.  */
 545       wait_reading_process_output (0, 5000000, 0, false, Qnil, NULL, 0);
 546       if (pending_signals)
 547         do_pending_atimers ();
 548     }
 549 #endif
 550   /* Shut up the compiler by "using" this variable.  */
 551   (void) timer;
 552
 553   for (i = 0, ok = 0; i < MAXTIMERS; i++)
 554     ok += results[i]->intime, xfree (results[i]);
 555
 556   return ok == MAXTIMERS ? Qt : Qnil;
 557 }
 558
 559 #endif /* ENABLE_CHECKING */
 560
 561 void
 562 init_atimer (void)
 563 {
 564 #ifdef HAVE_ITIMERSPEC
 565 # ifdef HAVE_TIMERFD
 566   /* Until this feature is considered stable, you can ask to not use it.  */
 567   timerfd = (egetenv ("EMACS_IGNORE_TIMERFD") ? -1 :
 568              timerfd_create (CLOCK_REALTIME, TFD_NONBLOCK | TFD_CLOEXEC));
 569 # endif
 570   if (timerfd < 0)
 571     {
 572       struct sigevent sigev;
 573       sigev.sigev_notify = SIGEV_SIGNAL;
 574       sigev.sigev_signo = SIGALRM;
 575       sigev.sigev_value.sival_ptr = &alarm_timer;
 576       alarm_timer_ok
 577         = timer_create (CLOCK_REALTIME, &sigev, &alarm_timer) == 0;
 578     }
 579 #endif
 580   free_atimers = stopped_atimers = atimers = NULL;
 581
 582   /* pending_signals is initialized in init_keyboard.  */
 583   struct sigaction action;
 584   emacs_sigaction_init (&action, handle_alarm_signal);
 585   sigaction (SIGALRM, &action, 0);
 586
 587 #ifdef ENABLE_CHECKING
 588   defsubr (&Sdebug_timer_check);
 589 #endif
 590 }