1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
3 mainloop.c for the Openbox window manager
4 Copyright (c) 2004 Mikael Magnusson
5 Copyright (c) 2003 Ben Jansens
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.
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.
17 See the COPYING file for a copy of the GNU General Public License.
26 #include <sys/select.h>
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
;
35 /* this should be more than the number of possible signals on any
37 #define NUM_SIGNALS 99
39 /* all created ObMainLoops. Used by the signal handler to pass along signals */
40 static GSList
*all_loops
;
42 /* signals are global to all loops */
44 guint installed
; /* a ref count */
45 struct sigaction oldact
;
46 } all_signals
[NUM_SIGNALS
];
48 /* a set of all possible signals */
49 sigset_t all_signals_set
;
51 /* signals which cause a core dump, these can't be used for callbacks */
52 static gint core_signals
[] =
65 #define NUM_CORE_SIGNALS (sizeof(core_signals) / sizeof(core_signals[0]))
67 static void sighandler(gint sig
);
68 static void timer_dispatch(ObMainLoop
*loop
, GTimeVal
**wait
);
69 static void fd_handler_destroy(gpointer data
);
75 gboolean run
; /* do keep running */
76 gboolean running
; /* is still running */
80 gint fd_x
; /* The X fd is a special case! */
82 GHashTable
*fd_handlers
;
89 gboolean signal_fired
;
90 guint signals_fired
[NUM_SIGNALS
];
91 GSList
*signal_handlers
[NUM_SIGNALS
];
96 struct _ObMainLoopTimer
101 GDestroyNotify destroy
;
103 /* The timer needs to be freed */
105 /* The time the last fire should've been at */
107 /* When this timer will next trigger */
111 struct _ObMainLoopSignalHandlerType
116 ObMainLoopSignalHandler func
;
117 GDestroyNotify destroy
;
120 struct _ObMainLoopXHandlerType
124 ObMainLoopXHandler func
;
125 GDestroyNotify destroy
;
128 struct _ObMainLoopFdHandlerType
133 ObMainLoopFdHandler func
;
134 GDestroyNotify destroy
;
137 ObMainLoop
*ob_main_loop_new(Display
*display
)
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
;
148 loop
->fd_handlers
= g_hash_table_new_full(g_int_hash
, g_int_equal
,
149 NULL
, fd_handler_destroy
);
151 g_get_current_time(&loop
->now
);
153 /* only do this if we're the first loop created */
156 struct sigaction action
;
159 /* initialize the all_signals_set */
160 sigfillset(&all_signals_set
);
162 sigemptyset(&sigset
);
163 action
.sa_handler
= sighandler
;
164 action
.sa_mask
= sigset
;
165 action
.sa_flags
= SA_NOCLDSTOP
;
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
++;
181 all_loops
= g_slist_prepend(all_loops
, loop
);
183 loop
->action_queue
= NULL
;
188 void ob_main_loop_destroy(ObMainLoop
*loop
)
194 g_assert(loop
->running
== FALSE
);
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
);
202 g_hash_table_destroy(loop
->fd_handlers
);
204 for (it
= loop
->timers
; it
; it
= g_slist_next(it
)) {
205 ObMainLoopTimer
*t
= it
->data
;
206 if (t
->destroy
) t
->destroy(t
->data
);
209 g_slist_free(loop
->timers
);
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
);
219 all_loops
= g_slist_remove(all_loops
, loop
);
221 /* only do this if we're the last loop destroyed */
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
--;
235 for (it
= loop
->action_queue
; it
; it
= g_slist_next(it
))
236 action_unref(it
->data
);
237 g_slist_free(loop
->action_queue
);
243 static void fd_handle_foreach(gpointer key
,
247 ObMainLoopFdHandlerType
*h
= value
;
250 if (FD_ISSET(h
->fd
, set
))
251 h
->func(h
->fd
, h
->data
);
254 void ob_main_loop_queue_action(ObMainLoop
*loop
, ObAction
*act
)
256 loop
->action_queue
= g_slist_append(loop
->action_queue
, action_copy(act
));
259 static void ob_main_loop_client_destroy(ObClient
*client
, gpointer data
)
261 ObMainLoop
*loop
= data
;
264 for (it
= loop
->action_queue
; it
; it
= g_slist_next(it
)) {
265 ObAction
*act
= it
->data
;
267 if (act
->data
.any
.c
== client
)
268 act
->data
.any
.c
= NULL
;
272 void ob_main_loop_run(ObMainLoop
*loop
)
275 struct timeval
*wait
;
281 loop
->running
= TRUE
;
283 client_add_destructor(ob_main_loop_client_destroy
, loop
);
286 if (loop
->signal_fired
) {
290 /* block signals so that we can do this without the data changing
292 sigprocmask(SIG_SETMASK
, &all_signals_set
, &oldset
);
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
;
301 loop
->signals_fired
[i
]--;
304 loop
->signal_fired
= FALSE
;
306 sigprocmask(SIG_SETMASK
, &oldset
, NULL
);
307 } else if (XPending(loop
->display
)) {
309 XNextEvent(loop
->display
, &e
);
311 for (it
= loop
->x_handlers
; it
; it
= g_slist_next(it
)) {
312 ObMainLoopXHandlerType
*h
= it
->data
;
313 h
->func(&e
, h
->data
);
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
322 act
= loop
->action_queue
->data
;
323 if (act
->data
.any
.client_action
== OB_CLIENT_ACTION_ALWAYS
&&
327 g_slist_delete_link(loop
->action_queue
,
332 } while (!act
&& loop
->action_queue
);
335 act
->func(&act
->data
);
337 g_slist_delete_link(loop
->action_queue
,
342 /* this only runs if there were no x events received */
344 timer_dispatch(loop
, (GTimeVal
**)&wait
);
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'
352 if (!loop
->signal_fired
)
353 select(loop
->fd_max
+ 1, &selset
, NULL
, NULL
, wait
);
355 /* handle the X events with highest prioirity */
356 if (FD_ISSET(loop
->fd_x
, &selset
))
359 g_hash_table_foreach(loop
->fd_handlers
,
360 fd_handle_foreach
, &selset
);
364 client_remove_destructor(ob_main_loop_client_destroy
);
366 loop
->running
= FALSE
;
369 void ob_main_loop_exit(ObMainLoop
*loop
)
374 /*** XEVENT WATCHERS ***/
376 void ob_main_loop_x_add(ObMainLoop
*loop
,
377 ObMainLoopXHandler handler
,
379 GDestroyNotify notify
)
381 ObMainLoopXHandlerType
*h
;
383 h
= g_new(ObMainLoopXHandlerType
, 1);
388 loop
->x_handlers
= g_slist_prepend(loop
->x_handlers
, h
);
391 void ob_main_loop_x_remove(ObMainLoop
*loop
,
392 ObMainLoopXHandler handler
)
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
);
407 /*** SIGNAL WATCHERS ***/
409 static void sighandler(gint sig
)
414 g_return_if_fail(sig
< NUM_SIGNALS
);
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... */
421 fprintf(stderr
, "Fuck yah. Core dump. (Signal=%d)\n", sig
);
423 /* die with a core dump */
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
]++;
434 void ob_main_loop_signal_add(ObMainLoop
*loop
,
436 ObMainLoopSignalHandler handler
,
438 GDestroyNotify notify
)
440 ObMainLoopSignalHandlerType
*h
;
442 g_return_if_fail(signal
< NUM_SIGNALS
);
444 h
= g_new(ObMainLoopSignalHandlerType
, 1);
450 loop
->signal_handlers
[h
->signal
] =
451 g_slist_prepend(loop
->signal_handlers
[h
->signal
], h
);
453 if (!all_signals
[signal
].installed
) {
454 struct sigaction action
;
457 sigemptyset(&sigset
);
458 action
.sa_handler
= sighandler
;
459 action
.sa_mask
= sigset
;
460 action
.sa_flags
= SA_NOCLDSTOP
;
462 sigaction(signal
, &action
, &all_signals
[signal
].oldact
);
465 all_signals
[signal
].installed
++;
468 void ob_main_loop_signal_remove(ObMainLoop
*loop
,
469 ObMainLoopSignalHandler handler
)
474 for (i
= 0; i
< NUM_SIGNALS
; ++i
) {
475 for (it
= loop
->signal_handlers
[i
]; it
; it
= next
) {
476 ObMainLoopSignalHandlerType
*h
= it
->data
;
478 next
= g_slist_next(it
);
480 if (h
->func
== handler
) {
481 g_assert(all_signals
[h
->signal
].installed
> 0);
483 all_signals
[h
->signal
].installed
--;
484 if (!all_signals
[h
->signal
].installed
) {
485 sigaction(h
->signal
, &all_signals
[h
->signal
].oldact
, NULL
);
488 loop
->signal_handlers
[i
] =
489 g_slist_delete_link(loop
->signal_handlers
[i
], it
);
490 if (h
->destroy
) h
->destroy(h
->data
);
499 /*** FILE DESCRIPTOR WATCHERS ***/
501 static void max_fd_func(gpointer key
, gpointer value
, gpointer data
)
503 ObMainLoop
*loop
= data
;
506 loop
->fd_max
= MAX(loop
->fd_max
, *(gint
*)key
);
509 static void calc_max_fd(ObMainLoop
*loop
)
511 loop
->fd_max
= loop
->fd_x
;
513 g_hash_table_foreach(loop
->fd_handlers
, max_fd_func
, loop
);
516 void ob_main_loop_fd_add(ObMainLoop
*loop
,
518 ObMainLoopFdHandler handler
,
520 GDestroyNotify notify
)
522 ObMainLoopFdHandlerType
*h
;
524 h
= g_new(ObMainLoopFdHandlerType
, 1);
531 g_hash_table_replace(loop
->fd_handlers
, &h
->fd
, h
);
532 FD_SET(h
->fd
, &loop
->fd_set
);
536 static void fd_handler_destroy(gpointer data
)
538 ObMainLoopFdHandlerType
*h
= data
;
540 FD_CLR(h
->fd
, &h
->loop
->fd_set
);
546 void ob_main_loop_fd_remove(ObMainLoop
*loop
,
549 g_hash_table_remove(loop
->fd_handlers
, &fd
);
554 #define NEAREST_TIMEOUT(loop) \
555 (((ObMainLoopTimer*)(loop)->timers->data)->timeout)
557 static glong
timecompare(GTimeVal
*a
, GTimeVal
*b
)
561 if ((r
= b
->tv_sec
- a
->tv_sec
)) return r
;
562 return b
->tv_usec
- a
->tv_usec
;
566 static void insert_timer(ObMainLoop
*loop
, ObMainLoopTimer
*ins
)
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
);
576 if (it
== NULL
) /* didnt fit anywhere in the list */
577 loop
->timers
= g_slist_append(loop
->timers
, ins
);
580 void ob_main_loop_timeout_add(ObMainLoop
*loop
,
584 GDestroyNotify notify
)
586 ObMainLoopTimer
*t
= g_new(ObMainLoopTimer
, 1);
587 t
->delay
= microseconds
;
592 g_get_current_time(&loop
->now
);
593 t
->last
= t
->timeout
= loop
->now
;
594 g_time_val_add(&t
->timeout
, t
->delay
);
596 insert_timer(loop
, t
);
599 void ob_main_loop_timeout_remove(ObMainLoop
*loop
,
604 for (it
= loop
->timers
; it
; it
= g_slist_next(it
)) {
605 ObMainLoopTimer
*t
= it
->data
;
606 if (t
->func
== handler
)
611 void ob_main_loop_timeout_remove_data(ObMainLoop
*loop
,
617 for (it
= loop
->timers
; it
; it
= g_slist_next(it
)) {
618 ObMainLoopTimer
*t
= it
->data
;
619 if (t
->func
== handler
&& t
->data
== data
)
624 /* find the time to wait for the nearest timeout */
625 static gboolean
nearest_timeout_wait(ObMainLoop
*loop
, GTimeVal
*tm
)
627 if (loop
->timers
== NULL
)
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
;
633 while (tm
->tv_usec
< 0) {
634 tm
->tv_usec
+= G_USEC_PER_SEC
;
637 tm
->tv_sec
+= tm
->tv_usec
/ G_USEC_PER_SEC
;
638 tm
->tv_usec
%= G_USEC_PER_SEC
;
645 static void timer_dispatch(ObMainLoop
*loop
, GTimeVal
**wait
)
649 gboolean fired
= FALSE
;
651 g_get_current_time(&loop
->now
);
653 for (it
= loop
->timers
; it
; it
= next
) {
654 ObMainLoopTimer
*curr
;
656 next
= g_slist_next(it
);
660 /* since timer_stop doesn't actually free the timer, we have to do our
661 real freeing in here.
665 loop
->timers
= g_slist_delete_link(loop
->timers
, it
);
667 curr
->destroy(curr
->data
);
672 /* the queue is sorted, so if this timer shouldn't fire, none are
674 if (timecompare(&NEAREST_TIMEOUT(loop
), &loop
->now
) < 0)
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.
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
);
688 curr
->destroy(curr
->data
);
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.
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
;