aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--fdm.c124
-rw-r--r--fdm.h15
-rw-r--r--main.c462
-rw-r--r--meson.build1
-rw-r--r--terminal.h7
5 files changed, 408 insertions, 201 deletions
diff --git a/fdm.c b/fdm.c
new file mode 100644
index 00000000..9523ab5f
--- /dev/null
+++ b/fdm.c
@@ -0,0 +1,124 @@
+#include "fdm.h"
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <assert.h>
+#include <sys/epoll.h>
+
+#define LOG_MODULE "fdm"
+#define LOG_ENABLE_DBG 0
+#include "log.h"
+#include "tllist.h"
+
+struct fd {
+ int fd;
+ void *data;
+ fdm_handler_t handler;
+};
+
+struct fdm {
+ int epoll_fd;
+ tll(struct fd) fds;
+};
+
+struct fdm *
+fdm_init(void)
+{
+ int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
+ if (epoll_fd == -1) {
+ LOG_ERRNO("failed to create epoll FD");
+ return NULL;
+ }
+
+ struct fdm *fdm = malloc(sizeof(*fdm));
+ *fdm = (struct fdm){
+ .epoll_fd = epoll_fd,
+ .fds = tll_init(),
+ };
+ return fdm;
+}
+
+void
+fdm_destroy(struct fdm *fdm)
+{
+ if (fdm == NULL)
+ return;
+
+ if (tll_length(fdm->fds) > 0)
+ LOG_WARN("FD list not empty");
+
+ assert(tll_length(fdm->fds) == 0);
+
+ tll_free(fdm->fds);
+ close(fdm->epoll_fd);
+ free(fdm);
+}
+
+bool
+fdm_add(struct fdm *fdm, int fd, int events, fdm_handler_t handler, void *data)
+{
+#if defined(_DEBUG)
+ tll_foreach(fdm->fds, it) {
+ if (it->item.fd == fd) {
+ LOG_ERR("FD=%d already registered", fd);
+ return false;
+ }
+ }
+#endif
+
+ tll_push_back(
+ fdm->fds, ((struct fd){.fd = fd, .data = data, .handler = handler}));
+
+ struct epoll_event ev = {
+ .events = events,
+ .data = {.ptr = &tll_back(fdm->fds)},
+ };
+
+ if (epoll_ctl(fdm->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0) {
+ LOG_ERRNO("failed to register FD with epoll");
+ tll_pop_back(fdm->fds);
+ return false;
+ }
+
+ return true;
+}
+
+bool
+fdm_del(struct fdm *fdm, int fd)
+{
+ tll_foreach(fdm->fds, it) {
+ if (it->item.fd == fd) {
+ if (epoll_ctl(fdm->epoll_fd, EPOLL_CTL_DEL, fd, NULL) < 0)
+ LOG_ERRNO("failed to unregister FD=%d from epoll", fd);
+
+ tll_remove(fdm->fds, it);
+ return true;
+ }
+ }
+
+ LOG_ERR("no such FD: %d", fd);
+ return false;
+}
+
+bool
+fdm_poll(struct fdm *fdm)
+{
+ struct epoll_event events[tll_length(fdm->fds)];
+ int ret = epoll_wait(fdm->epoll_fd, events, tll_length(fdm->fds), -1);
+ if (ret == -1) {
+ if (errno == EINTR)
+ return true;
+
+ LOG_ERRNO("failed to epoll");
+ return false;
+ }
+
+ for (int i = 0; i < ret; i++) {
+ struct fd *fd = events[i].data.ptr;
+ if (!fd->handler(fdm, fd->fd, events[i].events, fd->data))
+ return false;
+ }
+
+ return true;
+}
diff --git a/fdm.h b/fdm.h
new file mode 100644
index 00000000..cd0fee2a
--- /dev/null
+++ b/fdm.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <stdbool.h>
+
+struct fdm;
+
+typedef bool (*fdm_handler_t)(struct fdm *fdm, int fd, int events, void *data);
+
+struct fdm *fdm_init(void);
+void fdm_destroy(struct fdm *fdm);
+
+bool fdm_add(struct fdm *fdm, int fd, int events, fdm_handler_t handler, void *data);
+bool fdm_del(struct fdm *fdm, int fd);
+
+bool fdm_poll(struct fdm *fdm);
diff --git a/main.c b/main.c
index dfb1982d..92104e6e 100644
--- a/main.c
+++ b/main.c
@@ -16,6 +16,7 @@
#include <sys/prctl.h>
#include <sys/wait.h>
#include <sys/time.h>
+#include <sys/epoll.h>
#include <wayland-client.h>
#include <wayland-cursor.h>
@@ -26,10 +27,11 @@
#include <xdg-decoration-unstable-v1.h>
#define LOG_MODULE "main"
-#define LOG_ENABLE_DBG 0
+#define LOG_ENABLE_DBG 1
#include "log.h"
#include "config.h"
+#include "fdm.h"
#include "font.h"
#include "grid.h"
#include "input.h"
@@ -389,6 +391,228 @@ static const struct wl_registry_listener registry_listener = {
.global_remove = &handle_global_remove,
};
+static bool
+fdm_wayl(struct fdm *fdm, int fd, int events, void *data)
+{
+ struct terminal *term = data;
+ int event_count = wl_display_dispatch(term->wl.display);
+
+ if (events & EPOLLHUP) {
+ LOG_ERR("disconnected from Wayland");
+ return false;
+ }
+
+ return event_count != -1 && !term->quit;
+}
+
+static bool
+fdm_ptmx(struct fdm *fdm, int fd, int events, void *data)
+{
+ struct terminal *term = data;
+
+ if (events & EPOLLHUP) {
+ term->quit = true;
+
+ if (!(events & EPOLLIN))
+ return false;
+ }
+
+ assert(events & EPOLLIN);
+
+ uint8_t buf[24 * 1024];
+ ssize_t count = read(term->ptmx, buf, sizeof(buf));
+
+ if (count < 0) {
+ if (errno == EAGAIN)
+ return true;
+
+ LOG_ERRNO("failed to read from pseudo terminal");
+ return false;
+ }
+
+ vt_from_slave(term, buf, count);
+
+ /*
+ * We likely need to re-render. But, we don't want to
+ * do it immediately. Often, a single client operation
+ * is done through multiple writes. Many times, we're
+ * so fast that we render mid-operation frames.
+ *
+ * For example, we might end up rendering a frame
+ * where the client just erased a line, while in the
+ * next frame, the client wrote to the same line. This
+ * causes screen "flashes".
+ *
+ * Mitigate by always incuring a small delay before
+ * rendering the next frame. This gives the client
+ * some time to finish the operation (and thus gives
+ * us time to receive the last writes before doing any
+ * actual rendering).
+ *
+ * We incur this delay *every* time we receive
+ * input. To ensure we don't delay rendering
+ * indefinitely, we start a second timer that is only
+ * reset when we render.
+ *
+ * Note that when the client is producing data at a
+ * very high pace, we're rate limited by the wayland
+ * compositor anyway. The delay we introduce here only
+ * has any effect when the renderer is idle.
+ *
+ * TODO: this adds input latency. Can we somehow hint
+ * ourselves we just received keyboard input, and in
+ * this case *not* delay rendering?
+ */
+ if (term->render.frame_callback == NULL) {
+ /* First timeout - reset each time we receive input. */
+ timerfd_settime(
+ term->delayed_render_timer.lower_fd, 0,
+ &(struct itimerspec){.it_value = {.tv_nsec = 1000000}},
+ NULL);
+
+ /* Second timeout - only reset when we render. Set to one
+ * frame (assuming 60Hz) */
+ if (!term->delayed_render_timer.is_armed) {
+ timerfd_settime(
+ term->delayed_render_timer.upper_fd, 0,
+ &(struct itimerspec){.it_value = {.tv_nsec = 16666666}},
+ NULL);
+ term->delayed_render_timer.is_armed = true;
+ }
+ }
+
+ return !(events & EPOLLHUP);
+}
+
+static bool
+fdm_repeat(struct fdm *fdm, int fd, int events, void *data)
+{
+ if (events & EPOLLHUP)
+ return false;
+
+ struct terminal *term = data;
+ uint64_t expiration_count;
+ ssize_t ret = read(
+ term->kbd.repeat.fd, &expiration_count, sizeof(expiration_count));
+
+ if (ret < 0) {
+ if (errno == EAGAIN)
+ return true;
+
+ LOG_ERRNO("failed to read repeat key from repeat timer fd");
+ return false;
+ }
+
+ term->kbd.repeat.dont_re_repeat = true;
+ for (size_t i = 0; i < expiration_count; i++)
+ input_repeat(term, term->kbd.repeat.key);
+ term->kbd.repeat.dont_re_repeat = false;
+ return true;
+}
+
+static bool
+fdm_flash(struct fdm *fdm, int fd, int events, void *data)
+{
+ if (events & EPOLLHUP)
+ return false;
+
+ struct terminal *term = data;
+ uint64_t expiration_count;
+ ssize_t ret = read(
+ term->flash.fd, &expiration_count, sizeof(expiration_count));
+
+ if (ret < 0) {
+ if (errno == EAGAIN)
+ return true;
+
+ LOG_ERRNO("failed to read flash timer");
+ return false;
+ }
+
+ LOG_DBG("flash timer expired %llu times",
+ (unsigned long long)expiration_count);
+
+ term->flash.active = false;
+ term_damage_view(term);
+ render_refresh(term);
+ return true;
+}
+
+static bool
+fdm_blink(struct fdm *fdm, int fd, int events, void *data)
+{
+ if (events & EPOLLHUP)
+ return false;
+
+ struct terminal *term = data;
+ uint64_t expiration_count;
+ ssize_t ret = read(
+ term->blink.fd, &expiration_count, sizeof(expiration_count));
+
+ if (ret < 0) {
+ if (errno == EAGAIN)
+ return true;
+
+ LOG_ERRNO("failed to read blink timer");
+ return false;
+ }
+
+ LOG_DBG("blink timer expired %llu times",
+ (unsigned long long)expiration_count);
+
+ term->blink.state = term->blink.state == BLINK_ON
+ ? BLINK_OFF : BLINK_ON;
+
+ /* Scan all visible cells and mark rows with blinking cells dirty */
+ for (int r = 0; r < term->rows; r++) {
+ struct row *row = grid_row_in_view(term->grid, r);
+ for (int col = 0; col < term->cols; col++) {
+ struct cell *cell = &row->cells[col];
+
+ if (cell->attrs.blink) {
+ cell->attrs.clean = 0;
+ row->dirty = true;
+ }
+ }
+ }
+
+ render_refresh(term);
+ return true;
+}
+
+static bool
+fdm_delayed_render(struct fdm *fdm, int fd, int events, void *data)
+{
+ if (events & EPOLLHUP)
+ return false;
+
+ struct terminal *term = data;
+ assert(term->delayed_render_timer.is_armed);
+
+ uint64_t unused;
+ ssize_t ret1 = 0;
+ ssize_t ret2 = 0;
+
+ if (fd == term->delayed_render_timer.lower_fd)
+ ret1 = read(term->delayed_render_timer.lower_fd, &unused, sizeof(unused));
+ if (fd == term->delayed_render_timer.upper_fd)
+ ret2 = read(term->delayed_render_timer.upper_fd, &unused, sizeof(unused));
+
+ if ((ret1 < 0 || ret2 < 0) && errno != EAGAIN)
+ LOG_ERRNO("failed to read timeout timer");
+ else if (ret1 > 0 || ret2 > 0) {
+ render_refresh(term);
+
+ /* Reset timers */
+ term->delayed_render_timer.is_armed = false;
+ timerfd_settime(term->delayed_render_timer.lower_fd, 0, &(struct itimerspec){.it_value = {0}}, NULL);
+ timerfd_settime(term->delayed_render_timer.upper_fd, 0, &(struct itimerspec){.it_value = {0}}, NULL);
+ } else
+ assert(false);
+
+ return true;
+}
+
static void
print_usage(const char *prog_name)
{
@@ -496,6 +720,8 @@ main(int argc, char *const *argv)
setlocale(LC_ALL, "");
setenv("TERM", conf.term, 1);
+ struct fdm *fdm = NULL;
+
struct terminal term = {
.quit = false,
.ptmx = posix_openpt(O_RDWR | O_NOCTTY),
@@ -570,6 +796,11 @@ main(int argc, char *const *argv)
.queue = tll_init(),
},
},
+ .delayed_render_timer = {
+ .is_armed = false,
+ .lower_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK | TFD_CLOEXEC),
+ .upper_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK | TFD_CLOEXEC),
+ },
};
LOG_INFO("using %zu rendering threads", term.render.workers.count);
@@ -873,215 +1104,42 @@ main(int argc, char *const *argv)
}
}
- bool timeout_is_armed = false;
- int delay_render_timer_lower = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK | TFD_CLOEXEC);
- int delay_render_timer_upper = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK | TFD_CLOEXEC);
-
- while (true) {
- struct pollfd fds[] = {
- {.fd = wl_display_get_fd(term.wl.display), .events = POLLIN},
- {.fd = term.ptmx, .events = POLLIN},
- {.fd = term.kbd.repeat.fd, .events = POLLIN},
- {.fd = term.flash.fd, .events = POLLIN},
- {.fd = term.blink.fd, .events = POLLIN},
- {.fd = delay_render_timer_lower, .events = POLLIN},
- {.fd = delay_render_timer_upper, .events = POLLIN},
- };
+ if ((fdm = fdm_init()) == NULL)
+ goto out;
- const size_t WL_FD = 0;
- const size_t PTMX_FD = 1;
- const size_t KBD_REPEAT_FD = 2;
- const size_t FLASH_FD = 3;
- const size_t BLINK_FD = 4;
- const size_t DELAY_LOWER_FD = 5;
- const size_t DELAY_UPPER_FD = 6;
+ fdm_add(fdm, wl_display_get_fd(term.wl.display), EPOLLIN, &fdm_wayl, &term);
+ fdm_add(fdm, term.ptmx, EPOLLIN, &fdm_ptmx, &term);
+ fdm_add(fdm, term.kbd.repeat.fd, EPOLLIN, &fdm_repeat, &term);
+ fdm_add(fdm, term.flash.fd, EPOLLIN, &fdm_flash, &term);
+ fdm_add(fdm, term.blink.fd, EPOLLIN, &fdm_blink, &term);
+ fdm_add(fdm, term.delayed_render_timer.lower_fd, EPOLLIN, &fdm_delayed_render, &term);
+ fdm_add(fdm, term.delayed_render_timer.upper_fd, EPOLLIN, &fdm_delayed_render, &term);
+ while (true) {
wl_display_flush(term.wl.display);
- int pret = poll(fds, sizeof(fds) / sizeof(fds[0]), -1);
-
- if (pret == -1) {
- if (errno == EINTR)
- continue;
-
- LOG_ERRNO("failed to poll file descriptors");
+ if (!fdm_poll(fdm))
break;
- }
-
- /* Delayed rendering timers (created when we receive input) */
- if (fds[DELAY_LOWER_FD].revents & POLLIN ||
- fds[DELAY_UPPER_FD].revents & POLLIN)
- {
- assert(timeout_is_armed);
-
- uint64_t unused;
- ssize_t ret1 = 0;
- ssize_t ret2 = 0;
-
- if (fds[DELAY_LOWER_FD].revents & POLLIN)
- ret1 = read(delay_render_timer_lower, &unused, sizeof(unused));
- if (fds[DELAY_UPPER_FD].revents & POLLIN)
- ret2 = read(delay_render_timer_upper, &unused, sizeof(unused));
-
- if ((ret1 < 0 || ret2 < 0) && errno != EAGAIN)
- LOG_ERRNO("failed to read timeout timer");
- else if (ret1 > 0 || ret2 > 0) {
- render_refresh(&term);
-
- /* Reset timers */
- timeout_is_armed = false;
- timerfd_settime(delay_render_timer_lower, 0, &(struct itimerspec){.it_value = {0}}, NULL);
- timerfd_settime(delay_render_timer_upper, 0, &(struct itimerspec){.it_value = {0}}, NULL);
- } else
- assert(false);
- }
-
- if (fds[WL_FD].revents & POLLIN) {
- wl_display_dispatch(term.wl.display);
- if (term.quit) {
- ret = EXIT_SUCCESS;
- break;
- }
- }
-
- if (fds[WL_FD].revents & POLLHUP) {
- LOG_WARN("disconnected from wayland");
- break;
- }
-
- if (fds[PTMX_FD].revents & POLLIN) {
- uint8_t data[24 * 1024];
- ssize_t count = read(term.ptmx, data, sizeof(data));
- if (count < 0 && errno != EAGAIN) {
- LOG_ERRNO("failed to read from pseudo terminal");
- break;
- }
-
- if (count > 0) {
- vt_from_slave(&term, data, count);
-
- /*
- * We likely need to re-render. But, we don't want to
- * do it immediately. Often, a single client operation
- * is done through multiple writes. Many times, we're
- * so fast that we render mid-operation frames.
- *
- * For example, we might end up rendering a frame
- * where the client just erased a line, while in the
- * next frame, the client wrote to the same line. This
- * causes screen "flashes".
- *
- * Mitigate by always incuring a small delay before
- * rendering the next frame. This gives the client
- * some time to finish the operation (and thus gives
- * us time to receive the last writes before doing any
- * actual rendering).
- *
- * We incur this delay *every* time we receive
- * input. To ensure we don't delay rendering
- * indefinitely, we start a second timer that is only
- * reset when we render.
- *
- * Note that when the client is producing data at a
- * very high pace, we're rate limited by the wayland
- * compositor anyway. The delay we introduce here only
- * has any effect when the renderer is idle.
- *
- * TODO: this adds input latency. Can we somehow hint
- * ourselves we just received keyboard input, and in
- * this case *not* delay rendering?
- */
- if (term.render.frame_callback == NULL) {
- /* First timeout - reset each time we receive input. */
- timerfd_settime(
- delay_render_timer_lower, 0,
- &(struct itimerspec){.it_value = {.tv_nsec = 1000000}},
- NULL);
-
- /* Second timeout - only reset when we render. Set to one frame (assuming 60Hz) */
- if (!timeout_is_armed) {
- timerfd_settime(
- delay_render_timer_upper, 0,
- &(struct itimerspec){.it_value = {.tv_nsec = 16666666}},
- NULL);
- timeout_is_armed = true;
- }
- }
- }
- }
-
- if (fds[PTMX_FD].revents & POLLHUP) {
- ret = EXIT_SUCCESS;
- break;
- }
-
- if (fds[KBD_REPEAT_FD].revents & POLLIN) {
- uint64_t expiration_count;
- ssize_t ret = read(
- term.kbd.repeat.fd, &expiration_count, sizeof(expiration_count));
-
- if (ret < 0 && errno != EAGAIN)
- LOG_ERRNO("failed to read repeat key from repeat timer fd");
- else if (ret > 0) {
- term.kbd.repeat.dont_re_repeat = true;
- for (size_t i = 0; i < expiration_count; i++)
- input_repeat(&term, term.kbd.repeat.key);
- term.kbd.repeat.dont_re_repeat = false;
- }
- }
-
- if (fds[FLASH_FD].revents & POLLIN) {
- uint64_t expiration_count;
- ssize_t ret = read(
- term.flash.fd, &expiration_count, sizeof(expiration_count));
-
- if (ret < 0 && errno != EAGAIN)
- LOG_ERRNO("failed to read flash timer");
- else if (ret > 0) {
- LOG_DBG("flash timer expired %llu times",
- (unsigned long long)expiration_count);
-
- term.flash.active = false;
- term_damage_view(&term);
- render_refresh(&term);
- }
- }
-
- if (fds[BLINK_FD].revents & POLLIN) {
- uint64_t expiration_count;
- ssize_t ret = read(
- term.blink.fd, &expiration_count, sizeof(expiration_count));
-
- if (ret < 0 && errno != EAGAIN)
- LOG_ERRNO("failed to read blink timer");
- else if (ret > 0) {
- LOG_DBG("blink timer expired %llu times",
- (unsigned long long)expiration_count);
-
- term.blink.state = term.blink.state == BLINK_ON
- ? BLINK_OFF : BLINK_ON;
-
- /* Scan all visible cells and mark rows with blinking cells dirty */
- for (int r = 0; r < term.rows; r++) {
- struct row *row = grid_row_in_view(term.grid, r);
- for (int col = 0; col < term.cols; col++) {
- struct cell *cell = &row->cells[col];
+ }
- if (cell->attrs.blink) {
- cell->attrs.clean = 0;
- row->dirty = true;
- }
- }
- }
+ if (term.quit)
+ ret = EXIT_SUCCESS;
- render_refresh(&term);
- }
- }
+out:
+ if (fdm != NULL) {
+ fdm_del(fdm, wl_display_get_fd(term.wl.display));
+ fdm_del(fdm, term.ptmx);
+ fdm_del(fdm, term.kbd.repeat.fd);
+ fdm_del(fdm, term.flash.fd);
+ fdm_del(fdm, term.blink.fd);
+ fdm_del(fdm, term.delayed_render_timer.lower_fd);
+ fdm_del(fdm, term.delayed_render_timer.upper_fd);
}
- close(delay_render_timer_lower);
- close(delay_render_timer_upper);
+ if (term.delayed_render_timer.lower_fd != -1)
+ close(term.delayed_render_timer.lower_fd);
+ if (term.delayed_render_timer.upper_fd != -1)
+ close(term.delayed_render_timer.upper_fd);
-out:
mtx_lock(&term.render.workers.lock);
assert(tll_length(term.render.workers.queue) == 0);
for (size_t i = 0; i < term.render.workers.count; i++) {
@@ -1230,6 +1288,8 @@ out:
ret = child_ret;
}
+ fdm_destroy(fdm);
+
config_free(conf);
return ret;
diff --git a/meson.build b/meson.build
index 22987aa4..590f5f8f 100644
--- a/meson.build
+++ b/meson.build
@@ -68,6 +68,7 @@ executable(
'config.c', 'config.h',
'commands.c', 'commands.h',
'csi.c', 'csi.h',
+ 'fdm.c', 'fdm.h',
'font.c', 'font.h',
'grid.c', 'grid.h',
'input.c', 'input.h',
diff --git a/terminal.h b/terminal.h
index 6f6e1d53..a10e1928 100644
--- a/terminal.h
+++ b/terminal.h
@@ -401,6 +401,13 @@ struct terminal {
bool was_flashing; /* Flash was active last time we rendered */
bool was_searching;
} render;
+
+ /* Temporary: for FDM */
+ struct {
+ bool is_armed;
+ int lower_fd;
+ int upper_fd;
+ } delayed_render_timer;
};
void term_reset(struct terminal *term, bool hard);