void kmscon_pty_unref(struct kmscon_pty *pty)
{
if (!pty || !pty->ref || --pty->ref)
return;
log_debug("free pty object");
kmscon_pty_close(pty);
kmscon_ring_free(pty->msgbuf);
ev_eloop_unref(pty->eloop);
free(pty);
}
static void destroy_app(struct kmscon_app *app)
{
kmscon_ui_free(app->ui);
kmscon_input_unref(app->input);
uterm_video_unref(app->video);
kmscon_vt_unref(app->vt);
ev_eloop_unregister_signal_cb(app->eloop, SIGINT, sig_generic, app);
ev_eloop_unregister_signal_cb(app->eloop, SIGTERM, sig_generic, app);
ev_eloop_rm_eloop(app->vt_eloop);
ev_eloop_unref(app->eloop);
}
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;
}
SHL_EXPORT
void uvt_ctx_unref(struct uvt_ctx *ctx)
{
if (!ctx || !ctx->ref || --ctx->ref)
return;
llog_debug(ctx, "free ctx %p", ctx);
shl_flagset_free(ctx->minors);
free(ctx->cuse_file);
ev_eloop_unref(ctx->eloop);
free(ctx);
}
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);
}
SHL_EXPORT
int uvt_ctx_new(struct uvt_ctx **out, uvt_log_t log, void *log_data)
{
struct uvt_ctx *ctx;
int ret;
if (!out)
return llog_dEINVAL(log, log_data);
ctx = malloc(sizeof(*ctx));
if (!ctx)
return llog_dENOMEM(log, log_data);
memset(ctx, 0, sizeof(*ctx));
ctx->ref = 1;
ctx->llog = log;
ctx->llog_data = log_data;
/* Default major/minor uses the TTY_MAJOR number with an offset of 2^15
* to avoid ID-clashes with any in-kernel TTY driver. As kernel drivers
* use static IDs only, a lower number would be fine, too, but lets be
* safe and just use high numbers. */
ctx->major = TTY_MAJOR;
ctx->minor_offset = 16384;
llog_debug(ctx, "new ctx %p", ctx);
ret = ev_eloop_new(&ctx->eloop, ctx->llog, ctx->llog_data);
if (ret)
goto err_free;
ctx->cuse_file = strdup("/dev/cuse");
if (!ctx->cuse_file) {
ret = llog_ENOMEM(ctx);
goto err_eloop;
}
ret = shl_flagset_new(&ctx->minors);
if (ret)
goto err_file;
*out = ctx;
return 0;
err_file:
free(ctx->cuse_file);
err_eloop:
ev_eloop_unref(ctx->eloop);
err_free:
free(ctx);
return ret;
}
void uterm_vt_master_unref(struct uterm_vt_master *vtm)
{
struct uterm_vt *vt;
if (!vtm || !vtm->ref || --vtm->ref)
return;
while (vtm->vts.next != &vtm->vts) {
vt = kmscon_dlist_entry(vtm->vts.next,
struct uterm_vt,
list);
uterm_vt_deallocate(vt);
}
ev_eloop_unref(vtm->eloop);
free(vtm);
}
void uterm_video_unref(struct uterm_video *video)
{
struct uterm_display *disp;
if (!video || !video->ref || --video->ref)
return;
log_info("free device %p", video);
VIDEO_CALL(video->ops->destroy, 0, video);
while ((disp = video->displays)) {
video->displays = disp->next;
disp->next = NULL;
uterm_display_unref(disp);
}
shl_hook_free(video->hook);
ev_eloop_unref(video->eloop);
free(video);
}
SHL_EXPORT
void uterm_video_unref(struct uterm_video *video)
{
struct uterm_display *disp;
if (!video || !video->ref || --video->ref)
return;
log_info("free device %p", video);
while (!shl_dlist_empty(&video->displays)) {
disp = shl_dlist_entry(video->displays.prev,
struct uterm_display, list);
uterm_display_unbind(disp);
}
VIDEO_CALL(video->ops->destroy, 0, video);
shl_hook_free(video->hook);
ev_eloop_unref(video->eloop);
free(video);
}
