uterm: add VT API

The uterm VT API is designed to support new user-space implementations of
vt-master APIs. If we are on seat0 and CONFIG_VT is enabled, we use the
kernel VT API. In all other cases we currently simply fall back to a
non-op but will implement in the future dbus based APIs or similar to
support VT switching, that is multi-session, on all seats.

Signed-off-by: David Herrmann <dh.herrmann@googlemail.com>

Makefile.am

@@ -57,6 +57,7 @@ libkmscon_core_la_SOURCES = \
 	src/uterm_video_drm.c \
 	src/uterm_monitor.c \
 	src/uterm_input.c \
+	src/uterm_vt.c \
 	src/gl.h \
 	src/gl_math.c \
 	src/gl_shader.c \

src/uterm.h

@@ -43,6 +43,37 @@
 #include <stdlib.h>
 #include "eloop.h"
 
+/*
+ * Virtual Terminals
+ * Virtual terminals allow controlling multiple virtual terminals on one real
+ * terminal. It is multi-seat capable and fully asynchronous.
+ */
+
+struct uterm_vt;
+struct uterm_vt_master;
+
+enum uterm_vt_action {
+	UTERM_VT_ACTIVATE,
+	UTERM_VT_DEACTIVATE,
+};
+
+typedef int (*uterm_vt_cb) (struct uterm_vt *vt, unsigned int action,
+			    void *data);
+
+int uterm_vt_master_new(struct uterm_vt_master **out,
+			struct ev_eloop *eloop);
+void uterm_vt_master_ref(struct uterm_vt_master *vtm);
+void uterm_vt_master_unref(struct uterm_vt_master *vtm);
+
+int uterm_vt_allocate(struct uterm_vt_master *vt, struct uterm_vt **out,
+		      const char *seat, uterm_vt_cb cb, void *data);
+void uterm_vt_deallocate(struct uterm_vt *vt);
+void uterm_vt_ref(struct uterm_vt *vt);
+void uterm_vt_unref(struct uterm_vt *vt);
+
+int uterm_vt_activate(struct uterm_vt *vt);
+int uterm_vt_deactivate(struct uterm_vt *vt);
+
 /*
  * Video Control
  * Linux provides 2 famous ways to access the video hardware: fbdev and drm

src/uterm_vt.c

@@ -0,0 +1,270 @@
+/*
+ * uterm - Linux User-Space Terminal
+ *
+ * Copyright (c) 2011-2012 David Herrmann <dh.herrmann@googlemail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * Virtual Terminals
+ */
+
+#include <errno.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include "eloop.h"
+#include "log.h"
+#include "misc.h"
+#include "uterm.h"
+#include "uterm_internal.h"
+#include "vt.h"
+
+#define LOG_SUBSYSTEM "vt"
+
+struct uterm_vt {
+	unsigned long ref;
+	struct kmscon_dlist list;
+	struct uterm_vt_master *vtm;
+
+	uterm_vt_cb cb;
+	void *data;
+
+	bool active;
+	struct kmscon_vt *vt;
+};
+
+struct uterm_vt_master {
+	unsigned long ref;
+	struct ev_eloop *eloop;
+
+	struct kmscon_dlist vts;
+};
+
+static int vt_call(struct uterm_vt *vt, unsigned int event)
+{
+	int ret;
+
+	switch (event) {
+	case UTERM_VT_ACTIVATE:
+		if (!vt->active) {
+			if (vt->cb) {
+				ret = vt->cb(vt, event, vt->data);
+				if (ret)
+					log_warning("vt event handler returned %d instead of 0 on activation", ret);
+			}
+			vt->active = true;
+		}
+		break;
+	case UTERM_VT_DEACTIVATE:
+		if (vt->active) {
+			if (vt->cb) {
+				ret = vt->cb(vt, event, vt->data);
+				if (ret)
+					return ret;
+			}
+			vt->active = false;
+		}
+		break;
+	}
+
+	return 0;
+}
+
+static bool vt_event(struct kmscon_vt *ovt, enum kmscon_vt_action action,
+		     void *data)
+{
+	struct uterm_vt *vt = data;
+	int ret;
+
+	switch (action) {
+	case KMSCON_VT_ENTER:
+		ret = vt_call(vt, UTERM_VT_ACTIVATE);
+		break;
+	case KMSCON_VT_LEAVE:
+		ret = vt_call(vt, UTERM_VT_DEACTIVATE);
+		break;
+	}
+
+	if (ret)
+		return false;
+
+	return true;
+}
+
+static void vt_idle_event(struct ev_eloop *eloop, void *unused, void *data)
+{
+	struct uterm_vt *vt = data;
+
+	ev_eloop_unregister_idle_cb(eloop, vt_idle_event, data);
+	vt_call(vt, UTERM_VT_ACTIVATE);
+}
+
+int uterm_vt_allocate(struct uterm_vt_master *vtm,
+		      struct uterm_vt **out,
+		      const char *seat,
+		      uterm_vt_cb cb,
+		      void *data)
+{
+	struct uterm_vt *vt;
+	int ret;
+
+	if (!vtm || !out)
+		return -EINVAL;
+	if (!seat)
+		seat = "seat0";
+
+	vt = malloc(sizeof(*vt));
+	if (!vt)
+		return -ENOMEM;
+	memset(vt, 0, sizeof(*vt));
+	vt->ref = 1;
+	vt->vtm = vtm;
+	vt->cb = cb;
+	vt->data = data;
+
+	if (!strcmp(seat, "seat0") && kmscon_vt_supported()) {
+		ret = kmscon_vt_new(&vt->vt, vt_event, vt);
+		if (ret)
+			goto err_free;
+		ret = kmscon_vt_open(vt->vt, KMSCON_VT_NEW, vt->vtm->eloop);
+		if (ret) {
+			kmscon_vt_unref(vt->vt);
+			goto err_free;
+		}
+	} else {
+		ret = ev_eloop_register_idle_cb(vtm->eloop, vt_idle_event,
+						vt->data);
+		if (ret)
+			goto err_free;
+	}
+
+	kmscon_dlist_link(&vtm->vts, &vt->list);
+	*out = vt;
+	return 0;
+
+err_free:
+	free(vt);
+	return ret;
+}
+
+void uterm_vt_deallocate(struct uterm_vt *vt)
+{
+	if (!vt || !vt->vtm)
+		return;
+
+	if (vt->vt) {
+		kmscon_vt_close(vt->vt);
+		kmscon_vt_unref(vt->vt);
+	} else {
+		ev_eloop_unregister_idle_cb(vt->vtm->eloop, vt_idle_event,
+					    vt->data);
+		vt_call(vt, UTERM_VT_DEACTIVATE);
+	}
+	kmscon_dlist_unlink(&vt->list);
+	vt->vtm = NULL;
+}
+
+void uterm_vt_ref(struct uterm_vt *vt)
+{
+	if (!vt || !vt->ref)
+		return;
+
+	++vt->ref;
+}
+
+void uterm_vt_unref(struct uterm_vt *vt)
+{
+	if (!vt || !vt->ref || --vt->ref)
+		return;
+
+	uterm_vt_deallocate(vt);
+	free(vt);
+}
+
+int uterm_vt_activate(struct uterm_vt *vt)
+{
+	if (!vt || !vt->vtm)
+		return -EINVAL;
+
+	if (vt->vt)
+		return kmscon_vt_enter(vt->vt);
+	else
+		return -EFAULT;
+}
+
+int uterm_vt_deactivate(struct uterm_vt *vt)
+{
+	if (!vt || !vt->vtm)
+		return -EINVAL;
+
+	if (vt->vt)
+		return kmscon_vt_leave(vt->vt);
+	else
+		return -EFAULT;
+}
+
+int uterm_vt_master_new(struct uterm_vt_master **out,
+			struct ev_eloop *eloop)
+{
+	struct uterm_vt_master *vtm;
+
+	if (!out || !eloop)
+		return -EINVAL;
+
+	vtm = malloc(sizeof(*vtm));
+	if (!vtm)
+		return -ENOMEM;
+	memset(vtm, 0, sizeof(*vtm));
+	vtm->ref = 1;
+	vtm->eloop = eloop;
+	kmscon_dlist_init(&vtm->vts);
+
+	ev_eloop_ref(vtm->eloop);
+	*out = vtm;
+	return 0;
+}
+
+void uterm_vt_master_ref(struct uterm_vt_master *vtm)
+{
+	if (!vtm || !vtm->ref)
+		return;
+
+	++vtm->ref;
+}
+
+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);
+}