nettika/buffybox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

buffyboard: track virtual terminals with /sys/class/tty/tty0/active

Browse source
This commit is contained in:
Vladimir Stoiakin 2025-07-03 14:19:10 +00:00 • committed by Johannes Marbach
parent d0ec4777cc
commit c4b3729047
12 changed files with 283 additions and 335 deletions
Download patch file Download diff file Expand all files Collapse all files

1
buffyboard/buffyboard.conf
View file

@ -7,3 +7,4 @@ default=breezy-light
#[quirks]
#fbdev_force_refresh=true
#ignore_unused_terminals=false

4
buffyboard/buffyboard.service.in
View file

@ -1,5 +1,6 @@
[Unit]
Documentation=https://gitlab.postmarketos.org/postmarketOS/buffybox
After=getty.target
[Service]
ExecStart=@bindir@/buffyboard
@ -36,3 +37,6 @@ SystemCallArchitectures=native
SystemCallFilter=@system-service
SystemCallFilter=~@privileged
SystemCallFilter=~@resources
[Install]
WantedBy=multi-user.target

5
buffyboard/config.c
View file

@ -63,6 +63,10 @@ static int parsing_handler(void* user_data, const char* section, const char* key
if (bbx_config_parse_bool(value, &(opts->quirks.fbdev_force_refresh))) {
return 1;
}
} else if (strcmp(key, "ignore_unused_terminals") == 0) {
if (bbx_config_parse_bool(value, &(opts->quirks.ignore_unused_terminals))) {
return 1;
}
}
}
@ -80,6 +84,7 @@ void bb_config_init_opts(bb_config_opts *opts) {
opts->input.pointer = true;
opts->input.touchscreen = true;
opts->quirks.fbdev_force_refresh = false;
opts->quirks.ignore_unused_terminals = true;
}
void bb_config_parse_directory(const char *path, bb_config_opts *opts) {

2
buffyboard/config.h
View file

@ -35,6 +35,8 @@ typedef struct {
typedef struct {
/* If true and using the framebuffer backend, force a refresh on every draw operation */
bool fbdev_force_refresh;
/* If true, do not automatically update the layout of new terminals and wait for SIGUSR1 */
bool ignore_unused_terminals;
} bb_config_opts_quirks;
/**

3
buffyboard/getty-buffyboard.conf Normal file
View file

@ -0,0 +1,3 @@
[Service]
ExecStartPost=-/usr/bin/kill -s SIGUSR1 buffyboard
StandardError=journal

192
buffyboard/main.c
View file

@ -19,13 +19,14 @@
#include "../shared/themes.h"
#include "../squeek2lvgl/sq2lv.h"
#include <limits.h>
#include <sys/epoll.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
/**
@ -35,37 +36,19 @@
bb_cli_opts cli_opts;
bb_config_opts conf_opts;
static bool resize_terminals = false;
static lv_obj_t *keyboard = NULL;
static sig_atomic_t redraw_requested = false;
/**
* Static prototypes
*/
/**
* Compute the denominator of the keyboard height factor. The keyboard height is calculated
* by dividing the display height by the denominator.
*
* @param width display width
* @param height display height
* @return denominator
*/
static int keyboard_height_denominator(int32_t width, int32_t height);
/**
* Handle termination signals sent to the process.
* Handle signals sent to the process.
*
* @param signum the signal's number
*/
static void sigaction_handler(int signum);
/**
* Callback for the terminal resizing timer.
*
* @param timer the timer object
*/
static void terminal_resize_timer_cb(lv_timer_t *timer);
static void signal_handler(int signum);
/**
* Handle LV_EVENT_VALUE_CHANGED events from the keyboard widget.
@ -93,25 +76,16 @@ static void pop_checked_modifier_keys(void);
* Static functions
*/
static int keyboard_height_denominator(int32_t width, int32_t height) {
return (height > width) ? 3 : 2;
}
static void sigaction_handler(int signum) {
LV_UNUSED(signum);
if (resize_terminals) {
bb_terminal_reset_all();
static void signal_handler(int signum) {
if (signum == SIGUSR1) {
redraw_requested = true;
return;
}
bb_terminal_reset_all();
exit(0);
}
static void terminal_resize_timer_cb(lv_timer_t *timer) {
LV_UNUSED(timer);
if (resize_terminals) {
bb_terminal_shrink_current();
}
}
static void keyboard_value_changed_cb(lv_event_t *event) {
lv_obj_t *kb = lv_event_get_target(event);
@ -196,23 +170,9 @@ int main(int argc, char *argv[]) {
bb_config_parse_directory("/etc/buffyboard.conf.d", &conf_opts);
bb_config_parse_files(cli_opts.config_files, cli_opts.num_config_files, &conf_opts);
/* Prepare for terminal resizing and reset */
resize_terminals = bb_terminal_init(2.0f / 3.0f);
if (resize_terminals) {
/* Clean up on termination */
struct sigaction action;
lv_memset(&action, 0, sizeof(action));
action.sa_handler = sigaction_handler;
sigaction(SIGINT, &action, NULL);
sigaction(SIGTERM, &action, NULL);
/* Resize current terminal */
bb_terminal_shrink_current();
}
/* Set up uinput device */
if (!bb_uinput_device_init(sq2lv_unique_scancodes, sq2lv_num_unique_scancodes)) {
return 1;
return EXIT_FAILURE;
}
/* Initialise LVGL and set up logging callback */
@ -223,17 +183,19 @@ int main(int argc, char *argv[]) {
lv_display_t *disp = lv_linux_fbdev_create();
if (access("/dev/fb0", F_OK) != 0) {
bbx_log(BBX_LOG_LEVEL_ERROR, "/dev/fb0 is not available");
sigaction_handler(SIGTERM);
return EXIT_FAILURE;
}
lv_linux_fbdev_set_file(disp, "/dev/fb0");
if (conf_opts.quirks.fbdev_force_refresh) {
lv_linux_fbdev_set_force_refresh(disp, true);
}
lv_display_set_physical_resolution(disp,
lv_display_get_horizontal_resolution(disp),
lv_display_get_vertical_resolution(disp));
/* Override display properties with command line options if necessary */
lv_display_set_offset(disp, cli_opts.x_offset, cli_opts.y_offset);
if (cli_opts.hor_res > 0 || cli_opts.ver_res > 0) {
lv_display_set_physical_resolution(disp, lv_display_get_horizontal_resolution(disp), lv_display_get_vertical_resolution(disp));
if (cli_opts.hor_res > 0 && cli_opts.ver_res > 0) {
lv_display_set_resolution(disp, cli_opts.hor_res, cli_opts.ver_res);
}
if (cli_opts.dpi > 0) {
@ -241,27 +203,29 @@ int main(int argc, char *argv[]) {
}
/* Set up display rotation */
int32_t hor_res_phys = lv_display_get_horizontal_resolution(disp);
int32_t ver_res_phys = lv_display_get_vertical_resolution(disp);
lv_display_set_physical_resolution(disp, hor_res_phys, ver_res_phys);
lv_display_set_rotation(disp, cli_opts.rotation);
const int32_t hor_res = lv_display_get_horizontal_resolution(disp);
const int32_t ver_res = lv_display_get_vertical_resolution(disp);
const int32_t keyboard_height = ver_res > hor_res ? ver_res / 3 : ver_res / 2;
const int32_t tty_height = ver_res - keyboard_height;
switch (cli_opts.rotation) {
case LV_DISPLAY_ROTATION_0:
case LV_DISPLAY_ROTATION_180: {
int32_t denom = keyboard_height_denominator(hor_res_phys, ver_res_phys);
lv_display_set_resolution(disp, hor_res_phys, ver_res_phys / denom);
lv_display_set_offset(disp, 0, (cli_opts.rotation == LV_DISPLAY_ROTATION_0) ? (denom - 1) * ver_res_phys / denom : 0);
break;
}
case LV_DISPLAY_ROTATION_90:
case LV_DISPLAY_ROTATION_270: {
int32_t denom = keyboard_height_denominator(ver_res_phys, hor_res_phys);
lv_display_set_resolution(disp, hor_res_phys / denom, ver_res_phys);
lv_display_set_offset(disp, 0, (cli_opts.rotation == LV_DISPLAY_ROTATION_90) ? (denom - 1) * hor_res_phys / denom : 0);
break;
}
case LV_DISPLAY_ROTATION_0:
case LV_DISPLAY_ROTATION_180:
lv_display_set_resolution(disp, hor_res, keyboard_height);
lv_display_set_offset(disp, 0, cli_opts.rotation == LV_DISPLAY_ROTATION_0? tty_height : 0);
break;
case LV_DISPLAY_ROTATION_90:
case LV_DISPLAY_ROTATION_270:
lv_display_set_resolution(disp, keyboard_height, hor_res);
lv_display_set_offset(disp, cli_opts.rotation == LV_DISPLAY_ROTATION_90? tty_height : 0, 0);
break;
}
/* Prepare for terminal resizing and reset */
bb_terminal_init(tty_height - 8, hor_res, ver_res);
/* Start input device monitor and auto-connect available devices */
bbx_indev_start_monitor_and_autoconnect(false, conf_opts.input.pointer, conf_opts.input.touchscreen);
@ -286,13 +250,89 @@ int main(int argc, char *argv[]) {
/* Apply default keyboard layout */
sq2lv_switch_layout(keyboard, SQ2LV_LAYOUT_TERMINAL_US);
/* Start timer for periodically resizing terminals */
lv_timer_create(terminal_resize_timer_cb, 1000, NULL);
/* Open the file to track virtual terminals */
int fd_tty = open("/sys/class/tty/tty0/active", O_RDONLY|O_NOCTTY|O_CLOEXEC);
if (fd_tty < 0) {
perror("Can't open /sys/class/tty/tty0/active");
return EXIT_FAILURE;
}
int fd_epoll = epoll_create1(EPOLL_CLOEXEC);
if (fd_epoll == -1) {
perror("epoll_create1() is failed");
return EXIT_FAILURE;
}
struct epoll_event event;
event.events = EPOLLIN|EPOLLET;
event.data.fd = fd_tty;
int r = epoll_ctl(fd_epoll, EPOLL_CTL_ADD, fd_tty, &event);
if (r == -1) {
perror("epoll_ctl() is failed");
return EXIT_FAILURE;
}
/* Set signal handlers */
struct sigaction action;
action.sa_handler = signal_handler;
action.sa_flags = 0;
sigfillset(&action.sa_mask);
sigaction(SIGINT, &action, NULL);
sigaction(SIGTERM, &action, NULL);
action.sa_flags = SA_RESTART;
sigemptyset(&action.sa_mask);
sigaction(SIGUSR1, &action, NULL);
sigset_t sigmask;
sigemptyset(&sigmask);
sigaddset(&sigmask, SIGUSR1);
sigprocmask(SIG_BLOCK, &sigmask, NULL);
sigemptyset(&sigmask);
/* Periodically run timer / task handler */
while(1) {
uint32_t time_till_next = lv_timer_handler();
usleep(time_till_next * 1000);
int r = epoll_pwait(fd_epoll, &event, 1, time_till_next, &sigmask);
if (r == 0)
continue;
if (r < 0) {
if (errno != EINTR) {
perror("epoll_wait() is failed");
return EXIT_FAILURE;
}
if (!redraw_requested)
continue;
redraw_requested = false;
} else if (conf_opts.quirks.ignore_unused_terminals) {
lseek(fd_tty, 0, SEEK_SET);
char buffer[8];
ssize_t size = read(fd_tty, buffer, sizeof(buffer));
if (size <= 0) {
bbx_log(BBX_LOG_LEVEL_WARNING, "Can't read /sys/class/tty/tty0/active");
continue;
}
buffer[size] = 0;
unsigned int tty;
if (sscanf(buffer, "tty%u", &tty) != 1) {
bbx_log(BBX_LOG_LEVEL_WARNING, "Unexpected value of /sys/class/tty/tty0/active");
continue;
}
if (!bb_terminal_is_busy(tty)) {
bbx_log(BBX_LOG_LEVEL_VERBOSE, "Terminal %u isn't used, skip automatic update.", tty);
continue;
}
}
bb_terminal_shrink_current();
lv_obj_invalidate(keyboard);
}
return 0;

6
buffyboard/meson.build
View file

@ -40,4 +40,10 @@ if depsystemd.found()
install_dir: system_unit_dir,
install_tag: 'buffyboard'
)
install_data('getty-buffyboard.conf',
rename: 'buffyboard.conf',
install_dir: system_unit_dir / 'getty@.service.d',
install_tag: 'buffyboard'
)
endif

359
buffyboard/terminal.c
View file

@ -3,16 +3,14 @@
* SPDX-License-Identifier: GPL-3.0-or-later
*/
#include "terminal.h"
#include <errno.h>
#include <fcntl.h>
#include <math.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <linux/kd.h>
#include <linux/vt.h>
#include <sys/ioctl.h>
@ -22,260 +20,121 @@
* Static variables
*/
static int current_fd = -1;
static int current_vt = -1;
static bool resized_vts[MAX_NR_CONSOLES];
static float height_factor = 1;
/**
* Static prototypes
*/
/**
* Close the current file descriptor and reopen /dev/tty0.
*
* @return true if opening was successful, false otherwise
*/
static bool reopen_current_terminal(void);
/**
* Close the current file descriptor.
*/
static void close_current_terminal(void);
/**
* Get the currently active virtual terminal.
*
* @return number of the active VT (e.g. 7 for /dev/tty7)
*/
static int get_active_terminal(void);
/**
* Retrieve a terminal's size.
*
* @param fd TTY file descriptor
* @param size pointer to winsize struct for writing the size into
* @return true if the operation was successful, false otherwise. On failure, errno will be set
* to the value set by the failed system call.
*/
static bool get_terminal_size(int fd, struct winsize *size);
/**
* Update a terminal's size.
*
* @param fd TTY file descriptor
* @param size pointer to winsize struct for reading the new size from
* @return true if the operation was successful, false otherwise. On failure, errno will be set
* to the value set by the failed system call.
*/
static bool set_terminal_size(int fd, struct winsize *size);
/**
* Shrink the height of a terminal by the current factor.
*
* @param fd TTY file descriptor
* @return true if the operation was successful, false otherwise
*/
static bool shrink_terminal(int fd);
/**
* Reset the height of a terminal to the maximum.
*
* @param fd TTY file descriptor
* @param size pointer to winsize struct for writing the final size into
* @return true if the operation was successful, false otherwise
*/
static bool reset_terminal(int fd, struct winsize *size);
/**
* Static functions
*/
static bool reopen_current_terminal(void) {
close_current_terminal();
current_fd = open("/dev/tty0", O_RDWR | O_NOCTTY);
if (current_fd < 0) {
perror("Could not open /dev/tty0");
return false;
}
return true;
}
static void close_current_terminal(void) {
if (current_fd < 0) {
return;
}
close(current_fd);
current_fd = -1;
}
static int get_active_terminal(void) {
struct vt_stat stat;
if (ioctl(current_fd, VT_GETSTATE, &stat) != 0) {
perror("Could not retrieve current termimal state");
return -1;
}
return stat.v_active;
}
static bool get_terminal_size(int fd, struct winsize *size) {
if (ioctl(fd, TIOCGWINSZ, size) != 0) {
int errsv = errno;
perror("Could not retrieve current terminal size");
errno = errsv;
return false;
}
return true;
}
static bool set_terminal_size(int fd, struct winsize *size) {
if (ioctl(fd, TIOCSWINSZ, size) != 0) {
int errsv = errno;
perror("Could not update current terminal size");
errno = errsv;
return false;
}
return true;
}
static bool shrink_terminal(int fd) {
struct winsize size = { 0, 0, 0, 0 };
if (!reset_terminal(fd, &size)) {
perror("Could not shrink terminal size");
return false;
}
size.ws_row = floor((float)size.ws_row * height_factor);
if (!set_terminal_size(fd, &size)) {
perror("Could not shrink terminal size");
return false;
}
return true;
}
static bool reset_terminal(int fd, struct winsize *size) {
if (!get_terminal_size(fd, size)) {
perror("Could not reset terminal size");
return false;
}
/* Test-resize by two rows. If the terminal is already maximised, this will fail and we can exit early. */
size->ws_row += 2;
if (!set_terminal_size(fd, size)) {
bool is_max = (errno == EINVAL);
size->ws_row -= 2;
return is_max;
}
size->ws_row = floor((float)size->ws_row / height_factor);
if (!set_terminal_size(fd, size)) {
if (errno != EINVAL) {
perror("Could not reset terminal size");
return false;
}
/* Size too large. Reduce by one row until it fits. */
do {
size->ws_row -= 1;
} while (size->ws_row > 0 && !set_terminal_size(fd, size) && errno == EINVAL);
if (errno != EINVAL || size->ws_row == 0) {
perror("Could not reset terminal size");
return false;
}
} else {
/* Size fits but may not max out available space. Increase by one row until it doesn't fit anymore. */
do {
size->ws_row += 1;
} while (set_terminal_size(fd, size));
if (errno != EINVAL) {
perror("Could not reset terminal size");
return false;
}
size->ws_row -= 1;
}
return true;
}
static int32_t _tty_size;
static int32_t _h_display_size;
static int32_t _v_display_size;
/**
* Public functions
*/
bool bb_terminal_init(float factor) {
if (!reopen_current_terminal()) {
perror("Could not prepare for terminal resizing");
void bb_terminal_init(int32_t tty_size, int32_t h_display_size, int32_t v_display_size) {
_tty_size = tty_size;
_h_display_size = h_display_size;
_v_display_size = v_display_size;
}
void bb_terminal_shrink_current() {
int fd = open("/dev/tty0", O_RDONLY|O_NOCTTY);
if (fd < 0)
return;
/* KDFONTOP returns EINVAL if we are not in the text mode,
so we can skip this check */
/*
int mode;
if (ioctl(fd, KDGETMODE, &mode) != 0)
goto end;
if (mode != KD_TEXT)
goto end;
*/
struct console_font_op cfo = {
.op = KD_FONT_OP_GET,
.width = UINT_MAX,
.height = UINT_MAX,
.charcount = UINT_MAX,
.data = NULL
};
if (ioctl(fd, KDFONTOP, &cfo) != 0)
goto end;
struct winsize size;
size.ws_row = _tty_size / cfo.height;
size.ws_col = _h_display_size / cfo.width;
ioctl(fd, TIOCSWINSZ, &size);
end:
close(fd);
}
void bb_terminal_reset_all() {
int fd = open("/dev/tty0", O_RDONLY|O_NOCTTY);
if (fd < 0)
return;
struct vt_stat state;
if (ioctl(fd, VT_GETSTATE, &state) != 0) {
close(fd);
return;
}
close(fd);
char buffer[sizeof("/dev/tty") + 2];
unsigned short mask = state.v_state >> 1;
unsigned int tty = 1;
for (; mask; mask >>= 1, tty++) {
if (mask & 0x01) {
sprintf(buffer, "/dev/tty%u", tty);
int tty_fd = open(buffer, O_RDONLY|O_NOCTTY);
if (tty_fd < 0)
continue;
/* KDFONTOP returns EINVAL if we are not in the text mode,
so we can skip this check */
/*
int mode;
if (ioctl(tty_fd, KDGETMODE, &mode) != 0)
goto end;
if (mode != KD_TEXT)
goto end;
*/
struct console_font_op cfo = {
.op = KD_FONT_OP_GET,
.width = UINT_MAX,
.height = UINT_MAX,
.charcount = UINT_MAX,
.data = NULL
};
if (ioctl(tty_fd, KDFONTOP, &cfo) != 0)
goto end;
struct winsize size;
size.ws_row = _v_display_size / cfo.height;
size.ws_col = _h_display_size / cfo.width;
ioctl(tty_fd, TIOCSWINSZ, &size);
end:
close(tty_fd);
}
}
}
bool bb_terminal_is_busy(unsigned int tty) {
/* We can use any other terminal than `tty` here. */
int fd = open(tty == 1? "/dev/tty2" : "/dev/tty1", O_RDONLY|O_NOCTTY);
if (fd < 0)
return false;
}
current_vt = get_active_terminal();
if (current_vt < 0) {
perror("Could not prepare for terminal resizing");
struct vt_stat state;
int r = ioctl(fd, VT_GETSTATE, &state);
close(fd);
if (r != 0)
return false;
}
height_factor = factor;
return true;
}
void bb_terminal_shrink_current(void) {
int active_vt = get_active_terminal();
if (active_vt < 0) {
perror("Could not resize current terminal");
return;
}
if (active_vt < 0 || active_vt > MAX_NR_CONSOLES - 1) {
perror("Could not resize current terminal, index is out of bounds");
return;
}
if (resized_vts[active_vt - 1]) {
return; /* Already resized */
}
if (active_vt != current_vt) {
if (!reopen_current_terminal()) {
perror("Could not resize current terminal");
return;
}
current_vt = active_vt;
}
if (!shrink_terminal(current_fd)) {
perror("Could not resize current terminal");
return;
}
resized_vts[current_vt - 1] = true;
}
void bb_terminal_reset_all(void) {
char device[16];
struct winsize size = { 0, 0, 0, 0 };
for (int i = 0; i < MAX_NR_CONSOLES; ++i) {
if (!resized_vts[i]) {
continue;
}
snprintf(device, 16, "/dev/tty%d", i + 1);
int fd = open(device, O_RDWR | O_NOCTTY);
if (fd < 0) {
perror("Could not reset TTY, unable to open TTY");
continue;
}
reset_terminal(fd, &size);
}
return (state.v_state >> tty) & 0x01;
}

24
buffyboard/terminal.h
View file

@ -8,24 +8,30 @@
#define BB_TERMINAL_H
#include <stdbool.h>
#include <stdint.h>
/**
* Prepare for resizing terminals by opening the current one.
* Prepare for resizing terminals.
*
* @param factor factor (between 0 and 1) by which to adapt terminal sizes
* @return true if the operation was successful, false otherwise. No other bb_terminal_* functions
* must be called if false is returned.
* @param tty_size vertical size of the tty area in pixels
* @param h_display_size horizontal resolution of the display in pixels
* @param v_display_size vertical resolution of the display in pixels
*/
bool bb_terminal_init(float factor);
void bb_terminal_init(int32_t tty_size, int32_t h_display_size, int32_t v_display_size);
/**
* Shrink the height of the active terminal by the current factor.
* Shrink the height of the active terminal.
*/
void bb_terminal_shrink_current(void);
void bb_terminal_shrink_current();
/**
* Re-maximise the height of all previously resized terminals.
* Re-maximise the size of all active terminals.
*/
void bb_terminal_reset_all(void);
void bb_terminal_reset_all();
/**
* Check whether the terminal is opened by some process
*/
bool bb_terminal_is_busy(unsigned int tty);
#endif /* BB_TERMINAL_H */