From 4056c09e13c1aeead6dd4085fc7e263a17a0b195 Mon Sep 17 00:00:00 2001 From: Ryan Dwyer Date: Sat, 13 Oct 2018 16:04:37 +1000 Subject: [PATCH] Move swaybar's event loop to common directory and refactor * The loop functions are now prefixed with `loop_`. * It is now easy to add timers to the loop. * Timers are implemented using pollfd and timerfd, rather than manually checking them when any other event happens to arrive. --- common/loop.c | 105 +++++++++++++++++++++++ common/meson.build | 1 + include/loop.h | 47 ++++++++++ include/swaybar/bar.h | 5 ++ include/swaybar/event_loop.h | 26 ------ include/swaybar/status_line.h | 2 + swaybar/bar.c | 17 ++-- swaybar/event_loop.c | 156 ---------------------------------- swaybar/meson.build | 1 - swaybar/status_line.c | 4 +- 10 files changed, 172 insertions(+), 192 deletions(-) create mode 100644 common/loop.c create mode 100644 include/loop.h delete mode 100644 include/swaybar/event_loop.h delete mode 100644 swaybar/event_loop.c diff --git a/common/loop.c b/common/loop.c new file mode 100644 index 00000000..bfbfd5a6 --- /dev/null +++ b/common/loop.c @@ -0,0 +1,105 @@ +#include +#include +#include +#include +#include +#include +#include +#include "list.h" +#include "log.h" +#include "loop.h" + +struct loop_event { + void (*callback)(int fd, short mask, void *data); + void *data; +}; + +struct loop { + struct pollfd *fds; + int fd_length; + int fd_capacity; + + list_t *events; // struct loop_event +}; + +struct loop *loop_create(void) { + struct loop *loop = calloc(1, sizeof(struct loop)); + if (!loop) { + wlr_log(WLR_ERROR, "Unable to allocate memory for loop"); + return NULL; + } + loop->fd_capacity = 10; + loop->fds = malloc(sizeof(struct pollfd) * loop->fd_capacity); + loop->events = create_list(); + return loop; +} + +void loop_destroy(struct loop *loop) { + list_foreach(loop->events, free); + list_free(loop->events); + free(loop); +} + +void loop_poll(struct loop *loop) { + poll(loop->fds, loop->fd_length, -1); + + for (int i = 0; i < loop->fd_length; ++i) { + struct pollfd pfd = loop->fds[i]; + struct loop_event *event = loop->events->items[i]; + + // Always send these events + unsigned events = pfd.events | POLLHUP | POLLERR; + + if (pfd.revents & events) { + event->callback(pfd.fd, pfd.revents, event->data); + } + } +} + +struct loop_event *loop_add_fd(struct loop *loop, int fd, short mask, + void (*callback)(int fd, short mask, void *data), void *data) { + struct pollfd pfd = {fd, mask, 0}; + + if (loop->fd_length == loop->fd_capacity) { + loop->fd_capacity += 10; + loop->fds = realloc(loop->fds, sizeof(struct pollfd) * loop->fd_capacity); + } + + loop->fds[loop->fd_length++] = pfd; + + struct loop_event *event = calloc(1, sizeof(struct loop_event)); + event->callback = callback; + event->data = data; + + list_add(loop->events, event); + + return event; +} + +struct loop_event *loop_add_timer(struct loop *loop, int ms, + void (*callback)(int fd, short mask, void *data), void *data) { + int fd = timerfd_create(CLOCK_MONOTONIC, 0); + struct itimerspec its; + its.it_interval.tv_sec = 0; + its.it_interval.tv_nsec = 0; + its.it_value.tv_sec = ms / 1000000000; + its.it_value.tv_nsec = (ms * 1000000) % 1000000000; + timerfd_settime(fd, 0, &its, NULL); + + return loop_add_fd(loop, fd, POLLIN, callback, data); +} + +bool loop_remove_event(struct loop *loop, struct loop_event *event) { + for (int i = 0; i < loop->events->length; ++i) { + if (loop->events->items[i] == event) { + list_del(loop->events, i); + + loop->fd_length--; + memmove(&loop->fds[i], &loop->fds[i + 1], sizeof(void*) * (loop->fd_length - i)); + + free(event); + return true; + } + } + return false; +} diff --git a/common/meson.build b/common/meson.build index 44a29508..224a9c3f 100644 --- a/common/meson.build +++ b/common/meson.build @@ -5,6 +5,7 @@ lib_sway_common = static_library( 'cairo.c', 'ipc-client.c', 'log.c', + 'loop.c', 'list.c', 'pango.c', 'readline.c', diff --git a/include/loop.h b/include/loop.h new file mode 100644 index 00000000..7c151785 --- /dev/null +++ b/include/loop.h @@ -0,0 +1,47 @@ +#ifndef _SWAY_LOOP_H +#define _SWAY_LOOP_H +#include + +/** + * This is an event loop system designed for sway clients, not sway itself. + * + * It uses pollfds to block on multiple file descriptors at once, and provides + * an easy way to set timers. Typically the Wayland display's fd will be one of + * the fds in the loop. + */ + +struct loop; + +/** + * Create an event loop. + */ +struct loop *loop_create(void); + +/** + * Destroy the event loop (eg. on program termination). + */ +void loop_destroy(struct loop *loop); + +/** + * Poll the event loop. This will block until one of the fds has data. + */ +void loop_poll(struct loop *loop); + +/** + * Add an fd to the loop. + */ +struct loop_event *loop_add_fd(struct loop *loop, int fd, short mask, + void (*func)(int fd, short mask, void *data), void *data); + +/** + * Add a timer to the loop. + */ +struct loop_event *loop_add_timer(struct loop *loop, int ms, + void (*callback)(int fd, short mask, void *data), void *data); + +/** + * Remove an event from the loop. + */ +bool loop_remove_event(struct loop *loop, struct loop_event *event); + +#endif diff --git a/include/swaybar/bar.h b/include/swaybar/bar.h index 9ff3fe7b..d61da5dc 100644 --- a/include/swaybar/bar.h +++ b/include/swaybar/bar.h @@ -8,6 +8,8 @@ struct swaybar_config; struct swaybar_output; struct swaybar_workspace; +struct loop; +struct loop_event; struct swaybar_pointer { struct wl_pointer *pointer; @@ -66,6 +68,9 @@ struct swaybar { struct swaybar_pointer pointer; struct status_line *status; + struct loop *eventloop; + struct loop_event *status_event; + int ipc_event_socketfd; int ipc_socketfd; diff --git a/include/swaybar/event_loop.h b/include/swaybar/event_loop.h deleted file mode 100644 index 47be5b79..00000000 --- a/include/swaybar/event_loop.h +++ /dev/null @@ -1,26 +0,0 @@ -#ifndef _SWAYBAR_EVENT_LOOP_H -#define _SWAYBAR_EVENT_LOOP_H -#include -#include - -void add_event(int fd, short mask, - void(*cb)(int fd, short mask, void *data), - void *data); - -// Not guaranteed to notify cb immediately -void add_timer(timer_t timer, - void(*cb)(timer_t timer, void *data), - void *data); - -// Returns false if nothing exists, true otherwise -bool remove_event(int fd); - -// Returns false if nothing exists, true otherwise -bool remove_timer(timer_t timer); - -// Blocks and returns after sending callbacks -void event_loop_poll(void); - -void init_event_loop(void); - -#endif diff --git a/include/swaybar/status_line.h b/include/swaybar/status_line.h index 5e7e8771..957a808e 100644 --- a/include/swaybar/status_line.h +++ b/include/swaybar/status_line.h @@ -14,6 +14,8 @@ enum status_protocol { }; struct status_line { + struct swaybar *bar; + pid_t pid; int read_fd, write_fd; FILE *read, *write; diff --git a/swaybar/bar.c b/swaybar/bar.c index 9f72c94c..8e89c9a8 100644 --- a/swaybar/bar.c +++ b/swaybar/bar.c @@ -18,7 +18,6 @@ #endif #include "swaybar/bar.h" #include "swaybar/config.h" -#include "swaybar/event_loop.h" #include "swaybar/i3bar.h" #include "swaybar/ipc.h" #include "swaybar/status_line.h" @@ -26,6 +25,7 @@ #include "ipc-client.h" #include "list.h" #include "log.h" +#include "loop.h" #include "pool-buffer.h" #include "wlr-layer-shell-unstable-v1-client-protocol.h" #include "xdg-output-unstable-v1-client-protocol.h" @@ -573,7 +573,7 @@ static void set_bar_dirty(struct swaybar *bar) { bool bar_setup(struct swaybar *bar, const char *socket_path) { bar_init(bar); - init_event_loop(); + bar->eventloop = loop_create(); bar->ipc_socketfd = ipc_open_socket(socket_path); bar->ipc_event_socketfd = ipc_open_socket(socket_path); @@ -582,6 +582,7 @@ bool bar_setup(struct swaybar *bar, const char *socket_path) { } if (bar->config->status_command) { bar->status = status_line_init(bar->config->status_command); + bar->status->bar = bar; } bar->display = wl_display_connect(NULL); @@ -646,21 +647,23 @@ static void status_in(int fd, short mask, void *data) { if (mask & (POLLHUP | POLLERR)) { status_error(bar->status, "[error reading from status command]"); set_bar_dirty(bar); - remove_event(fd); + loop_remove_event(bar->eventloop, bar->status_event); } else if (status_handle_readable(bar->status)) { set_bar_dirty(bar); } } void bar_run(struct swaybar *bar) { - add_event(wl_display_get_fd(bar->display), POLLIN, display_in, bar); - add_event(bar->ipc_event_socketfd, POLLIN, ipc_in, bar); + loop_add_fd(bar->eventloop, wl_display_get_fd(bar->display), POLLIN, + display_in, bar); + loop_add_fd(bar->eventloop, bar->ipc_event_socketfd, POLLIN, ipc_in, bar); if (bar->status) { - add_event(bar->status->read_fd, POLLIN, status_in, bar); + bar->status_event = loop_add_fd( + bar->eventloop, bar->status->read_fd, POLLIN, status_in, bar); } while (1) { wl_display_flush(bar->display); - event_loop_poll(); + loop_poll(bar->eventloop); } } diff --git a/swaybar/event_loop.c b/swaybar/event_loop.c deleted file mode 100644 index 686b9962..00000000 --- a/swaybar/event_loop.c +++ /dev/null @@ -1,156 +0,0 @@ -#define _XOPEN_SOURCE 700 -#include -#include -#include -#include -#include -#include -#include "swaybar/event_loop.h" -#include "list.h" - -struct event_item { - void (*cb)(int fd, short mask, void *data); - void *data; -}; - -struct timer_item { - timer_t timer; - void (*cb)(timer_t timer, void *data); - void *data; -}; - -static struct { - // The order of each must be kept consistent - struct { /* pollfd array */ - struct pollfd *items; - int capacity; - int length; - } fds; - list_t *items; /* event_item list */ - - // Timer list - list_t *timers; -} event_loop; - -void add_timer(timer_t timer, - void(*cb)(timer_t timer, void *data), - void *data) { - - struct timer_item *item = malloc(sizeof(struct timer_item)); - item->timer = timer; - item->cb = cb; - item->data = data; - - list_add(event_loop.timers, item); -} - -void add_event(int fd, short mask, - void(*cb)(int fd, short mask, void *data), void *data) { - - struct pollfd pollfd = { - fd, - mask, - 0, - }; - - // Resize - if (event_loop.fds.length == event_loop.fds.capacity) { - event_loop.fds.capacity += 10; - event_loop.fds.items = realloc(event_loop.fds.items, - sizeof(struct pollfd) * event_loop.fds.capacity); - } - - event_loop.fds.items[event_loop.fds.length++] = pollfd; - - struct event_item *item = malloc(sizeof(struct event_item)); - item->cb = cb; - item->data = data; - - list_add(event_loop.items, item); - - return; -} - -bool remove_event(int fd) { - /* - * Instead of removing events immediately, we mark them for deletion - * and clean them up later. This is so we can call remove_event inside - * an event callback safely. - */ - for (int i = 0; i < event_loop.fds.length; ++i) { - if (event_loop.fds.items[i].fd == fd) { - event_loop.fds.items[i].fd = -1; - return true; - } - } - return false; -} - -static int timer_item_timer_cmp(const void *_timer_item, const void *_timer) { - const struct timer_item *timer_item = _timer_item; - const timer_t *timer = _timer; - if (timer_item->timer == *timer) { - return 0; - } else { - return -1; - } -} -bool remove_timer(timer_t timer) { - int index = list_seq_find(event_loop.timers, timer_item_timer_cmp, &timer); - if (index != -1) { - free(event_loop.timers->items[index]); - list_del(event_loop.timers, index); - return true; - } - return false; -} - -void event_loop_poll(void) { - poll(event_loop.fds.items, event_loop.fds.length, -1); - - for (int i = 0; i < event_loop.fds.length; ++i) { - struct pollfd pfd = event_loop.fds.items[i]; - struct event_item *item = (struct event_item *)event_loop.items->items[i]; - - // Always send these events - unsigned events = pfd.events | POLLHUP | POLLERR; - - if (pfd.revents & events) { - item->cb(pfd.fd, pfd.revents, item->data); - } - } - - // Cleanup removed events - int end = 0; - int length = event_loop.fds.length; - for (int i = 0; i < length; ++i) { - if (event_loop.fds.items[i].fd == -1) { - free(event_loop.items->items[i]); - list_del(event_loop.items, i); - --event_loop.fds.length; - } else if (end != i) { - event_loop.fds.items[end++] = event_loop.fds.items[i]; - } else { - end = i + 1; - } - } - - // check timers - // not tested, but seems to work - for (int i = 0; i < event_loop.timers->length; ++i) { - struct timer_item *item = event_loop.timers->items[i]; - int overrun = timer_getoverrun(item->timer); - if (overrun && overrun != -1) { - item->cb(item->timer, item->data); - } - } -} - -void init_event_loop(void) { - event_loop.fds.length = 0; - event_loop.fds.capacity = 10; - event_loop.fds.items = malloc( - event_loop.fds.capacity * sizeof(struct pollfd)); - event_loop.items = create_list(); - event_loop.timers = create_list(); -} diff --git a/swaybar/meson.build b/swaybar/meson.build index 7a02a33f..0c116172 100644 --- a/swaybar/meson.build +++ b/swaybar/meson.build @@ -2,7 +2,6 @@ executable( 'swaybar', [ 'bar.c', 'config.c', - 'event_loop.c', 'i3bar.c', 'ipc.c', 'main.c', diff --git a/swaybar/status_line.c b/swaybar/status_line.c index 000609ce..3f7a386f 100644 --- a/swaybar/status_line.c +++ b/swaybar/status_line.c @@ -7,16 +7,16 @@ #include #include #include +#include "loop.h" #include "swaybar/bar.h" #include "swaybar/config.h" #include "swaybar/i3bar.h" -#include "swaybar/event_loop.h" #include "swaybar/status_line.h" #include "readline.h" static void status_line_close_fds(struct status_line *status) { if (status->read_fd != -1) { - remove_event(status->read_fd); + loop_remove_event(status->bar->eventloop, status->bar->status_event); close(status->read_fd); status->read_fd = -1; }