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