openbox/mainloop.c

   1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
   2
   3    mainloop.c for the Openbox window manager
   4    Copyright (c) 2003        Ben Jansens
   5
   6    This program 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 of the License, or
   9    (at your option) any later version.
  10
  11    This program 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    See the COPYING file for a copy of the GNU General Public License.
  17 */
  18
  19 #include "mainloop.h"
  20 #include "action.h"
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <sys/select.h>
  25 #include <signal.h>
  26
  27 typedef struct _ObMainLoopTimer             ObMainLoopTimer;
  28 typedef struct _ObMainLoopSignal            ObMainLoopSignal;
  29 typedef struct _ObMainLoopSignalHandlerType ObMainLoopSignalHandlerType;
  30 typedef struct _ObMainLoopXHandlerType      ObMainLoopXHandlerType;
  31 typedef struct _ObMainLoopFdHandlerType     ObMainLoopFdHandlerType;
  32
  33 /* this should be more than the number of possible signals on any
  34    architecture... */
  35 #define NUM_SIGNALS 99
  36
  37 /* all created ObMainLoops. Used by the signal handler to pass along signals */
  38 static GSList *all_loops;
  39
  40 /* signals are global to all loops */
  41 struct {
  42     guint installed; /* a ref count */
  43     struct sigaction oldact;
  44 } all_signals[NUM_SIGNALS];
  45
  46 /* a set of all possible signals */
  47 sigset_t all_signals_set;
  48
  49 /* signals which cause a core dump, these can't be used for callbacks */
  50 static gint core_signals[] =
  51 {
  52     SIGABRT,
  53     SIGSEGV,
  54     SIGFPE,
  55     SIGILL,
  56     SIGQUIT,
  57     SIGTRAP,
  58     SIGSYS,
  59     SIGBUS,
  60     SIGXCPU,
  61     SIGXFSZ
  62 };
  63 #define NUM_CORE_SIGNALS (sizeof(core_signals) / sizeof(core_signals[0]))
  64
  65 static void sighandler(gint sig);
  66 static void timer_dispatch(ObMainLoop *loop, GTimeVal **wait);
  67 static void fd_handler_destroy(gpointer data);
  68
  69 struct _ObMainLoop
  70 {
  71     Display *display;
  72
  73     gboolean run;     /* do keep running */
  74     gboolean running; /* is still running */
  75
  76     GSList *x_handlers;
  77
  78     gint fd_x; /* The X fd is a special case! */
  79     gint fd_max;
  80     GHashTable *fd_handlers;
  81     fd_set fd_set;
  82
  83     GSList *timers;
  84     GTimeVal now;
  85     GTimeVal ret_wait;
  86
  87     gboolean signal_fired;
  88     guint signals_fired[NUM_SIGNALS];
  89     GSList *signal_handlers[NUM_SIGNALS];
  90
  91     GQueue *action_queue;
  92 };
  93
  94 struct _ObMainLoopTimer
  95 {
  96     gulong delay;
  97     GSourceFunc func;
  98     gpointer data;
  99     GDestroyNotify destroy;
 100
 101     /* The timer needs to be freed */
 102     gboolean del_me;
 103     /* The time the last fire should've been at */
 104     GTimeVal last;
 105     /* When this timer will next trigger */
 106     GTimeVal timeout;
 107 };
 108
 109 struct _ObMainLoopSignalHandlerType
 110 {
 111     ObMainLoop *loop;
 112     gint signal;
 113     gpointer data;
 114     ObMainLoopSignalHandler func;
 115     GDestroyNotify destroy;
 116 };
 117
 118 struct _ObMainLoopXHandlerType
 119 {
 120     ObMainLoop *loop;
 121     gpointer data;
 122     ObMainLoopXHandler func;
 123     GDestroyNotify destroy;
 124 };
 125
 126 struct _ObMainLoopFdHandlerType
 127 {
 128     ObMainLoop *loop;
 129     gint fd;
 130     gpointer data;
 131     ObMainLoopFdHandler func;
 132     GDestroyNotify destroy;
 133 };
 134
 135 ObMainLoop *ob_main_loop_new(Display *display)
 136 {
 137     ObMainLoop *loop;
 138
 139     loop = g_new0(ObMainLoop, 1);
 140     loop->display = display;
 141     loop->fd_x = ConnectionNumber(display);
 142     FD_ZERO(&loop->fd_set);
 143     FD_SET(loop->fd_x, &loop->fd_set);
 144     loop->fd_max = loop->fd_x;
 145
 146     loop->fd_handlers = g_hash_table_new_full(g_int_hash, g_int_equal,
 147                                               NULL, fd_handler_destroy);
 148
 149     g_get_current_time(&loop->now);
 150
 151     /* only do this if we're the first loop created */
 152     if (!all_loops) {
 153         guint i;
 154         struct sigaction action;
 155         sigset_t sigset;
 156
 157         /* initialize the all_signals_set */
 158         sigfillset(&all_signals_set);
 159
 160         sigemptyset(&sigset);
 161         action.sa_handler = sighandler;
 162         action.sa_mask = sigset;
 163         action.sa_flags = SA_NOCLDSTOP;
 164
 165         /* grab all the signals that cause core dumps */
 166         for (i = 0; i < NUM_CORE_SIGNALS; ++i) {
 167             /* SIGABRT is curiously not grabbed here!! that's because when we
 168                get one of the core_signals, we use abort() to dump the core.
 169                And having the abort() only go back to our signal handler again
 170                is less than optimal */
 171             if (core_signals[i] != SIGABRT) {
 172                 sigaction(core_signals[i], &action,
 173                           &all_signals[core_signals[i]].oldact);
 174                 all_signals[core_signals[i]].installed++;
 175             }
 176         }
 177     }
 178
 179     all_loops = g_slist_prepend(all_loops, loop);
 180
 181     loop->action_queue = g_queue_new();
 182
 183     return loop;
 184 }
 185
 186 void ob_main_loop_destroy(ObMainLoop *loop)
 187 {
 188     guint i;
 189     GSList *it, *next;
 190
 191     if (loop) {
 192         g_assert(loop->running == FALSE);
 193
 194         for (it = loop->x_handlers; it; it = next) {
 195             ObMainLoopXHandlerType *h = it->data;
 196             next = g_slist_next(it);
 197             ob_main_loop_x_remove(loop, h->func);
 198         }
 199
 200         g_hash_table_destroy(loop->fd_handlers);
 201
 202         for (it = loop->timers; it; it = g_slist_next(it)) {
 203             ObMainLoopTimer *t = it->data;
 204             if (t->destroy) t->destroy(t->data);
 205             g_free(t);
 206         }
 207         g_slist_free(loop->timers);
 208         loop->timers = NULL;
 209
 210         for (i = 0; i < NUM_SIGNALS; ++i)
 211             for (it = loop->signal_handlers[i]; it; it = next) {
 212                 ObMainLoopSignalHandlerType *h = it->data;
 213                 next = g_slist_next(it);
 214                 ob_main_loop_signal_remove(loop, h->func);
 215             }
 216
 217         all_loops = g_slist_remove(all_loops, loop);
 218
 219         /* only do this if we're the last loop destroyed */
 220         if (!all_loops) {
 221             guint i;
 222
 223             /* grab all the signals that cause core dumps */
 224             for (i = 0; i < NUM_CORE_SIGNALS; ++i) {
 225                 if (all_signals[core_signals[i]].installed) {
 226                     sigaction(core_signals[i],
 227                               &all_signals[core_signals[i]].oldact, NULL);
 228                     all_signals[core_signals[i]].installed--;
 229                 }
 230             }
 231         }
 232
 233         g_queue_free(loop->action_queue);
 234
 235         g_free(loop);
 236     }
 237 }
 238
 239 static void fd_handle_foreach(gpointer key,
 240                               gpointer value,
 241                               gpointer data)
 242 {
 243     ObMainLoopFdHandlerType *h = value;
 244     fd_set *set = data;
 245
 246     if (FD_ISSET(h->fd, set))
 247         h->func(h->fd, h->data);
 248 }
 249
 250 void ob_main_loop_queue_action(ObMainLoop *loop, ObAction *act)
 251 {
 252     g_queue_push_tail(loop->action_queue, action_copy(act));
 253 }
 254
 255 void ob_main_loop_run(ObMainLoop *loop)
 256 {
 257     XEvent e;
 258     struct timeval *wait;
 259     fd_set selset;
 260     GSList *it;
 261     ObAction *act;
 262
 263     loop->run = TRUE;
 264     loop->running = TRUE;
 265
 266     while (loop->run) {
 267         if (loop->signal_fired) {
 268             guint i;
 269             sigset_t oldset;
 270
 271             /* block signals so that we can do this without the data changing
 272                on us */
 273             sigprocmask(SIG_SETMASK, &all_signals_set, &oldset);
 274
 275             for (i = 0; i < NUM_SIGNALS; ++i) {
 276                 while (loop->signals_fired[i]) {
 277                     for (it = loop->signal_handlers[i];
 278                          it; it = g_slist_next(it)) {
 279                         ObMainLoopSignalHandlerType *h = it->data;
 280                         h->func(i, h->data);
 281                     }
 282                     loop->signals_fired[i]--;
 283                 }
 284             }
 285             loop->signal_fired = FALSE;
 286
 287             sigprocmask(SIG_SETMASK, &oldset, NULL);
 288         } else if (XPending(loop->display)) {
 289             do {
 290                 XNextEvent(loop->display, &e);
 291
 292                 for (it = loop->x_handlers; it; it = g_slist_next(it)) {
 293                     ObMainLoopXHandlerType *h = it->data;
 294                     h->func(&e, h->data);
 295                 }
 296             } while (XPending(loop->display));
 297         } else if ((act = g_queue_pop_head(loop->action_queue))) {
 298              /* only fire off one action at a time, then go back for more
 299                 X events, since the action might cause some X events (like
 300                 FocusIn :) */
 301             act->func(&act->data);
 302             action_unref(act);
 303         } else {
 304             /* this only runs if there were no x events received */
 305
 306             timer_dispatch(loop, (GTimeVal**)&wait);
 307
 308             selset = loop->fd_set;
 309             /* there is a small race condition here. if a signal occurs
 310                between this if() and the select() then we will not process
 311                the signal until 'wait' expires. possible solutions include
 312                using GStaticMutex, and having the signal handler set 'wait'
 313                to 0 */
 314             if (!loop->signal_fired)
 315                 select(loop->fd_max + 1, &selset, NULL, NULL, wait);
 316
 317             /* handle the X events with highest prioirity */
 318             if (FD_ISSET(loop->fd_x, &selset))
 319                 continue;
 320
 321             g_hash_table_foreach(loop->fd_handlers,
 322                                  fd_handle_foreach, &selset);
 323         }
 324     }
 325
 326     loop->running = FALSE;
 327 }
 328
 329 void ob_main_loop_exit(ObMainLoop *loop)
 330 {
 331     loop->run = FALSE;
 332 }
 333
 334 /*** XEVENT WATCHERS ***/
 335
 336 void ob_main_loop_x_add(ObMainLoop *loop,
 337                         ObMainLoopXHandler handler,
 338                         gpointer data,
 339                         GDestroyNotify notify)
 340 {
 341     ObMainLoopXHandlerType *h;
 342
 343     h = g_new(ObMainLoopXHandlerType, 1);
 344     h->loop = loop;
 345     h->func = handler;
 346     h->data = data;
 347     h->destroy = notify;
 348     loop->x_handlers = g_slist_prepend(loop->x_handlers, h);
 349 }
 350
 351 void ob_main_loop_x_remove(ObMainLoop *loop,
 352                            ObMainLoopXHandler handler)
 353 {
 354     GSList *it, *next;
 355
 356     for (it = loop->x_handlers; it; it = next) {
 357         ObMainLoopXHandlerType *h = it->data;
 358         next = g_slist_next(it);
 359         if (h->func == handler) {
 360             loop->x_handlers = g_slist_delete_link(loop->x_handlers, it);
 361             if (h->destroy) h->destroy(h->data);
 362             g_free(h);
 363         }
 364     }
 365 }
 366
 367 /*** SIGNAL WATCHERS ***/
 368
 369 static void sighandler(gint sig)
 370 {
 371     GSList *it;
 372     guint i;
 373
 374     g_return_if_fail(sig < NUM_SIGNALS);
 375
 376     for (i = 0; i < NUM_CORE_SIGNALS; ++i)
 377         if (sig == core_signals[i]) {
 378             /* XXX special case for signals that default to core dump.
 379                but throw some helpful output here... */
 380
 381             fprintf(stderr, "Fuck yah. Core dump. (Signal=%d)\n", sig);
 382
 383             /* die with a core dump */
 384             abort();
 385         }
 386
 387     for (it = all_loops; it; it = g_slist_next(it)) {
 388         ObMainLoop *loop = it->data;
 389         loop->signal_fired = TRUE;
 390         loop->signals_fired[sig]++;
 391     }
 392 }
 393
 394 void ob_main_loop_signal_add(ObMainLoop *loop,
 395                              gint signal,
 396                              ObMainLoopSignalHandler handler,
 397                              gpointer data,
 398                              GDestroyNotify notify)
 399 {
 400     ObMainLoopSignalHandlerType *h;
 401
 402     g_return_if_fail(signal < NUM_SIGNALS);
 403
 404     h = g_new(ObMainLoopSignalHandlerType, 1);
 405     h->loop = loop;
 406     h->signal = signal;
 407     h->func = handler;
 408     h->data = data;
 409     h->destroy = notify;
 410     loop->signal_handlers[h->signal] =
 411         g_slist_prepend(loop->signal_handlers[h->signal], h);
 412
 413     if (!all_signals[signal].installed) {
 414         struct sigaction action;
 415         sigset_t sigset;
 416
 417         sigemptyset(&sigset);
 418         action.sa_handler = sighandler;
 419         action.sa_mask = sigset;
 420         action.sa_flags = SA_NOCLDSTOP;
 421
 422         sigaction(signal, &action, &all_signals[signal].oldact);
 423     }
 424
 425     all_signals[signal].installed++;
 426 }
 427
 428 void ob_main_loop_signal_remove(ObMainLoop *loop,
 429                                 ObMainLoopSignalHandler handler)
 430 {
 431     guint i;
 432     GSList *it, *next;
 433
 434     for (i = 0; i < NUM_SIGNALS; ++i) {
 435         for (it = loop->signal_handlers[i]; it; it = next) {
 436             ObMainLoopSignalHandlerType *h = it->data;
 437
 438             next = g_slist_next(it);
 439
 440             if (h->func == handler) {
 441                 g_assert(all_signals[h->signal].installed > 0);
 442
 443                 all_signals[h->signal].installed--;
 444                 if (!all_signals[h->signal].installed) {
 445                     sigaction(h->signal, &all_signals[h->signal].oldact, NULL);
 446                 }
 447
 448                 loop->signal_handlers[i] =
 449                     g_slist_delete_link(loop->signal_handlers[i], it);
 450                 if (h->destroy) h->destroy(h->data);
 451
 452                 g_free(h);
 453             }
 454         }
 455     }
 456
 457 }
 458
 459 /*** FILE DESCRIPTOR WATCHERS ***/
 460
 461 static void max_fd_func(gpointer key, gpointer value, gpointer data)
 462 {
 463     ObMainLoop *loop = data;
 464
 465     /* key is the fd */
 466     loop->fd_max = MAX(loop->fd_max, *(gint*)key);
 467 }
 468
 469 static void calc_max_fd(ObMainLoop *loop)
 470 {
 471     loop->fd_max = loop->fd_x;
 472
 473     g_hash_table_foreach(loop->fd_handlers, max_fd_func, loop);
 474 }
 475
 476 void ob_main_loop_fd_add(ObMainLoop *loop,
 477                          gint fd,
 478                          ObMainLoopFdHandler handler,
 479                          gpointer data,
 480                          GDestroyNotify notify)
 481 {
 482     ObMainLoopFdHandlerType *h;
 483
 484     h = g_new(ObMainLoopFdHandlerType, 1);
 485     h->loop = loop;
 486     h->fd = fd;
 487     h->func = handler;
 488     h->data = data;
 489     h->destroy = notify;
 490
 491     g_hash_table_replace(loop->fd_handlers, &h->fd, h);
 492     FD_SET(h->fd, &loop->fd_set);
 493     calc_max_fd(loop);
 494 }
 495
 496 static void fd_handler_destroy(gpointer data)
 497 {
 498     ObMainLoopFdHandlerType *h = data;
 499
 500     FD_CLR(h->fd, &h->loop->fd_set);
 501
 502     if (h->destroy)
 503         h->destroy(h->data);
 504 }
 505
 506 void ob_main_loop_fd_remove(ObMainLoop *loop,
 507                             gint fd)
 508 {
 509     g_hash_table_remove(loop->fd_handlers, &fd);
 510 }
 511
 512 /*** TIMEOUTS ***/
 513
 514 #define NEAREST_TIMEOUT(loop) \
 515     (((ObMainLoopTimer*)(loop)->timers->data)->timeout)
 516
 517 static long timecompare(GTimeVal *a, GTimeVal *b)
 518 {
 519     long r;
 520
 521     if ((r = b->tv_sec - a->tv_sec)) return r;
 522     return b->tv_usec - a->tv_usec;
 523
 524 }
 525
 526 static void insert_timer(ObMainLoop *loop, ObMainLoopTimer *ins)
 527 {
 528     GSList *it;
 529     for (it = loop->timers; it; it = g_slist_next(it)) {
 530         ObMainLoopTimer *t = it->data;
 531         if (timecompare(&ins->timeout, &t->timeout) >= 0) {
 532             loop->timers = g_slist_insert_before(loop->timers, it, ins);
 533             break;
 534         }
 535     }
 536     if (it == NULL) /* didnt fit anywhere in the list */
 537         loop->timers = g_slist_append(loop->timers, ins);
 538 }
 539
 540 void ob_main_loop_timeout_add(ObMainLoop *loop,
 541                               gulong microseconds,
 542                               GSourceFunc handler,
 543                               gpointer data,
 544                               GDestroyNotify notify)
 545 {
 546     ObMainLoopTimer *t = g_new(ObMainLoopTimer, 1);
 547     t->delay = microseconds;
 548     t->func = handler;
 549     t->data = data;
 550     t->destroy = notify;
 551     t->del_me = FALSE;
 552     g_get_current_time(&loop->now);
 553     t->last = t->timeout = loop->now;
 554     g_time_val_add(&t->timeout, t->delay);
 555
 556     insert_timer(loop, t);
 557 }
 558
 559 void ob_main_loop_timeout_remove(ObMainLoop *loop,
 560                                  GSourceFunc handler)
 561 {
 562     GSList *it;
 563
 564     for (it = loop->timers; it; it = g_slist_next(it)) {
 565         ObMainLoopTimer *t = it->data;
 566         if (t->func == handler)
 567             t->del_me = TRUE;
 568     }
 569 }
 570
 571 void ob_main_loop_timeout_remove_data(ObMainLoop *loop,
 572                                       GSourceFunc handler,
 573                                       gpointer data)
 574 {
 575     GSList *it;
 576
 577     for (it = loop->timers; it; it = g_slist_next(it)) {
 578         ObMainLoopTimer *t = it->data;
 579         if (t->func == handler && t->data == data)
 580             t->del_me = TRUE;
 581     }
 582 }
 583
 584 /* find the time to wait for the nearest timeout */
 585 static gboolean nearest_timeout_wait(ObMainLoop *loop, GTimeVal *tm)
 586 {
 587   if (loop->timers == NULL)
 588     return FALSE;
 589
 590   tm->tv_sec = NEAREST_TIMEOUT(loop).tv_sec - loop->now.tv_sec;
 591   tm->tv_usec = NEAREST_TIMEOUT(loop).tv_usec - loop->now.tv_usec;
 592
 593   while (tm->tv_usec < 0) {
 594     tm->tv_usec += G_USEC_PER_SEC;
 595     tm->tv_sec--;
 596   }
 597   tm->tv_sec += tm->tv_usec / G_USEC_PER_SEC;
 598   tm->tv_usec %= G_USEC_PER_SEC;
 599   if (tm->tv_sec < 0)
 600     tm->tv_sec = 0;
 601
 602   return TRUE;
 603 }
 604
 605 static void timer_dispatch(ObMainLoop *loop, GTimeVal **wait)
 606 {
 607     GSList *it, *next;
 608
 609     gboolean fired = FALSE;
 610
 611     g_get_current_time(&loop->now);
 612
 613     for (it = loop->timers; it; it = next) {
 614         ObMainLoopTimer *curr;
 615
 616         next = g_slist_next(it);
 617
 618         curr = it->data;
 619
 620         /* since timer_stop doesn't actually free the timer, we have to do our
 621            real freeing in here.
 622         */
 623         if (curr->del_me) {
 624             /* delete the top */
 625             loop->timers = g_slist_delete_link(loop->timers, it);
 626             g_free(curr);
 627             continue;
 628         }
 629
 630         /* the queue is sorted, so if this timer shouldn't fire, none are
 631            ready */
 632         if (timecompare(&NEAREST_TIMEOUT(loop), &loop->now) < 0)
 633             break;
 634
 635         /* we set the last fired time to delay msec after the previous firing,
 636            then re-insert.  timers maintain their order and may trigger more
 637            than once if they've waited more than one delay's worth of time.
 638         */
 639         loop->timers = g_slist_delete_link(loop->timers, it);
 640         g_time_val_add(&curr->last, curr->delay);
 641         if (curr->func(curr->data)) {
 642             g_time_val_add(&curr->timeout, curr->delay);
 643             insert_timer(loop, curr);
 644         } else {
 645             if (curr->destroy)
 646                 curr->destroy(curr->data);
 647             g_free(curr);
 648         }
 649
 650         fired = TRUE;
 651     }
 652
 653     if (fired) {
 654         /* if at least one timer fires, then don't wait on X events, as there
 655            may already be some in the queue from the timer callbacks.
 656         */
 657         loop->ret_wait.tv_sec = loop->ret_wait.tv_usec = 0;
 658         *wait = &loop->ret_wait;
 659     } else if (nearest_timeout_wait(loop, &loop->ret_wait))
 660         *wait = &loop->ret_wait;
 661     else
 662         *wait = NULL;
 663 }