openbox/mainloop.c

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