static void app_ctx_event(struct ev_fd *fd, int mask, void *data)
{
struct uvtd_app *app = data;
uvt_ctx_dispatch(app->ctx);
if (!(mask & EV_READABLE) && mask & (EV_HUP | EV_ERR)) {
log_error("HUP on UVT ctx fd");
ev_eloop_rm_fd(fd);
app->ctx_fd = NULL;
}
}
static void disconnect_eloop(struct kmscon_vt *vt)
{
if (!vt)
return;
ev_eloop_rm_fd(vt->efd);
ev_eloop_unregister_signal_cb(vt->eloop, SIGUSR2, vt_enter, vt);
ev_eloop_unregister_signal_cb(vt->eloop, SIGUSR1, vt_leave, vt);
ev_eloop_unref(vt->eloop);
vt->efd = NULL;
vt->eloop = NULL;
}
static void destroy_app(struct uvtd_app *app)
{
ev_eloop_rm_fd(app->ctx_fd);
uvt_ctx_unref(app->ctx);
uterm_monitor_unref(app->mon);
ev_eloop_unregister_signal_cb(app->eloop, SIGPIPE, app_sig_ignore,
app);
ev_eloop_unregister_signal_cb(app->eloop, SIGINT, app_sig_generic,
app);
ev_eloop_unregister_signal_cb(app->eloop, SIGTERM, app_sig_generic,
app);
ev_eloop_unref(app->eloop);
}
static void video_destroy(struct uterm_video *video)
{
struct dumb_video *dumb = &video->dumb;
struct uterm_display *disp;
while ((disp = video->displays)) {
video->displays = disp->next;
disp->next = NULL;
unbind_display(disp);
}
log_info("free drm device");
ev_eloop_rm_fd(dumb->efd);
drmDropMaster(dumb->fd);
close(dumb->fd);
}
static void event(struct ev_fd *fd, int mask, void *data)
{
struct uterm_video *video = data;
drmEventContext ev;
if (mask & (EV_HUP | EV_ERR)) {
log_err("error or hangup on DRM fd");
ev_eloop_rm_fd(video->dumb.efd);
video->dumb.efd = NULL;
return;
}
if (mask & EV_READABLE) {
memset(&ev, 0, sizeof(ev));
ev.version = DRM_EVENT_CONTEXT_VERSION;
ev.page_flip_handler = page_flip_handler;
drmHandleEvent(video->dumb.fd, &ev);
}
}
int kmscon_pty_open(struct kmscon_pty *pty, unsigned short width,
unsigned short height)
{
int ret;
int master;
if (!pty)
return -EINVAL;
if (pty_is_open(pty))
return -EALREADY;
master = posix_openpt(O_RDWR | O_NOCTTY | O_CLOEXEC | O_NONBLOCK);
if (master < 0) {
log_err("cannot open master: %m");
return -errno;
}
ret = ev_eloop_new_fd(pty->eloop, &pty->efd, master,
EV_READABLE, pty_input, pty);
if (ret)
goto err_master;
ret = ev_eloop_register_signal_cb(pty->eloop, SIGCHLD, sig_child, pty);
if (ret)
goto err_fd;
ret = pty_spawn(pty, master, width, height);
if (ret)
goto err_sig;
return 0;
err_sig:
ev_eloop_unregister_signal_cb(pty->eloop, SIGCHLD, sig_child, pty);
err_fd:
ev_eloop_rm_fd(pty->efd);
pty->efd = NULL;
err_master:
close(master);
return ret;
}
static void real_close(struct uterm_vt *vt)
{
struct vt_mode mode;
log_debug("closing vt %p", vt);
memset(&mode, 0, sizeof(mode));
mode.mode = VT_AUTO;
ioctl(vt->real_fd, VT_SETMODE, &mode);
ioctl(vt->real_fd, KDSETMODE, KD_TEXT);
tcsetattr(vt->real_fd, TCSANOW, &vt->real_saved_attribs);
ev_eloop_rm_fd(vt->real_efd);
vt->real_efd = NULL;
close(vt->real_fd);
vt->real_fd = -1;
vt->real_num = -1;
vt->real_saved_num = -1;
}
static void pty_close(struct kmscon_pty *pty, bool user)
{
bool called = true;
if (!pty || !pty_is_open(pty))
return;
if (pty->efd) {
called = false;
ev_eloop_rm_fd(pty->efd);
pty->efd = NULL;
}
if (!user) {
if (!called)
pty->input_cb(pty, NULL, 0, pty->data);
return;
}
ev_eloop_unregister_signal_cb(pty->eloop, SIGCHLD, sig_child, pty);
close(pty->fd);
pty->fd = -1;
}
static int real_open(struct uterm_vt *vt)
{
struct termios raw_attribs;
struct vt_mode mode;
struct vt_stat vts;
int ret;
sigset_t mask;
log_debug("open vt %p", vt);
ret = open_tty(-1, &vt->real_fd, &vt->real_num);
if (ret)
return ret;
ret = ev_eloop_new_fd(vt->vtm->eloop, &vt->real_efd, vt->real_fd,
EV_READABLE, real_input, vt);
if (ret)
goto err_fd;
/*
* Get the number of the VT which is active now, so we have something
* to switch back to in kmscon_vt_switch_leave.
*/
ret = ioctl(vt->real_fd, VT_GETSTATE, &vts);
if (ret) {
log_warn("cannot find the currently active VT");
vt->real_saved_num = -1;
} else {
vt->real_saved_num = vts.v_active;
}
if (tcgetattr(vt->real_fd, &vt->real_saved_attribs) < 0) {
log_err("cannot get terminal attributes");
ret = -EFAULT;
goto err_eloop;
}
/* Ignore control characters and disable echo */
raw_attribs = vt->real_saved_attribs;
cfmakeraw(&raw_attribs);
/* Fix up line endings to be normal (cfmakeraw hoses them) */
raw_attribs.c_oflag |= OPOST | OCRNL;
if (tcsetattr(vt->real_fd, TCSANOW, &raw_attribs) < 0)
log_warn("cannot put terminal into raw mode");
if (ioctl(vt->real_fd, KDSETMODE, KD_GRAPHICS)) {
log_err("vt: cannot set graphics mode\n");
ret = -errno;
goto err_reset;
}
memset(&mode, 0, sizeof(mode));
mode.mode = VT_PROCESS;
mode.acqsig = SIGUSR1;
mode.relsig = SIGUSR2;
if (ioctl(vt->real_fd, VT_SETMODE, &mode)) {
log_err("cannot take control of vt handling");
ret = -errno;
goto err_text;
}
sigemptyset(&mask);
sigaddset(&mask, SIGUSR1);
sigaddset(&mask, SIGUSR2);
sigprocmask(SIG_BLOCK, &mask, NULL);
return 0;
err_text:
ioctl(vt->real_fd, KDSETMODE, KD_TEXT);
err_reset:
tcsetattr(vt->real_fd, TCSANOW, &vt->real_saved_attribs);
err_eloop:
ev_eloop_rm_fd(vt->real_efd);
vt->real_efd = NULL;
err_fd:
close(vt->real_fd);
return ret;
}
