1 files changed, 485 insertions, 0 deletions
diff --git a/src/uvt_cdev.c b/src/uvt_cdev.c
new file mode 100644
index 0000000..291857b
--- /dev/null
+++ b/src/uvt_cdev.c
@@ -0,0 +1,485 @@
+/*
+ * UVT - Userspace Virtual Terminals
+ *
+ * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.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.
+ */
+
+/*
+ * Character Devices
+ * This implements a VT character device entry point via the CUSE API. It does
+ * not implement the VT API on top of the character-device (cdev) but only
+ * provides the entry point. It is up to the user to bind open-files to VT and
+ * client objects.
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <linux/major.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "shl_dlist.h"
+#include "shl_hook.h"
+#include "shl_llog.h"
+#include "uvt.h"
+#include "uvt_internal.h"
+
+#include <fuse/fuse.h>
+#include <fuse/fuse_common.h>
+#include <fuse/fuse_lowlevel.h>
+#include <fuse/fuse_opt.h>
+#include <fuse/cuse_lowlevel.h>
+
+#define LLOG_SUBSYSTEM "uvt_cdev"
+
+/*
+ * FUSE low-level ops
+ * This implements all the file-system operations on the character-device. It
+ * is important that we handle interrupts correctly (ENOENT) and never loose
+ * any data. This is all single threaded as it is not performance critical at
+ * all.
+ * We simply dispatch each call to uvt_client as this implements all the
+ * client-session related operations.
+ */
+
+static void ll_open(fuse_req_t req, struct fuse_file_info *fi)
+{
+	struct uvt_cdev *cdev = fuse_req_userdata(req);
+	struct uvt_client *client;
+	struct uvt_cdev_event ev;
+	int ret;
+
+	ret = uvt_client_ll_open(&client, cdev, req, fi);
+	if (ret)
+		return;
+
+	memset(&ev, 0, sizeof(ev));
+	ev.type = UVT_CDEV_OPEN;
+	ev.client = client;
+	shl_hook_call(cdev->hook, cdev, &ev);
+}
+
+static void ll_destroy(void *data) {
+	struct uvt_cdev *cdev = data;
+	struct uvt_client *client;
+
+	/* on unexpected shutdown this kills all open clients */
+	while (!shl_dlist_empty(&cdev->clients)) {
+		client = shl_dlist_entry(cdev->clients.next,
+					 struct uvt_client, list);
+		uvt_client_kill(client);
+		uvt_client_unref(client);
+	}
+}
+
+static const struct cuse_lowlevel_ops ll_ops = {
+	.init = NULL,
+	.destroy = ll_destroy,
+	.open = ll_open,
+	.release = uvt_client_ll_release,
+	.read = uvt_client_ll_read,
+	.write = uvt_client_ll_write,
+	.poll = uvt_client_ll_poll,
+	.ioctl = uvt_client_ll_ioctl,
+	.flush = NULL,
+	.fsync = NULL,
+};
+
+/*
+ * FUSE channel ops
+ * The connection to the FUSE kernel module is done via a file-descriptor.
+ * Writing to it is synchronous, so the commands that we write are
+ * _immediately_ executed and return the result to us. Furthermore, write()
+ * is always non-blocking and always succeeds so no reason to watch for
+ * EAGAIN. Reading from the FD, on the other hand, may block if there is no
+ * data available so we mark it as O_NONBLOCK. The kernel maintains
+ * an event-queue that we read from. So there may be pending events that we
+ * haven't read but which affect the calls that we write to the kernel. This
+ * is important when handling interrupts.
+ * chan_receive() and chan_send() handle I/O to the kernel module and are
+ * hooked up into a fuse-channel.
+ */
+
+static int chan_receive(struct fuse_chan **chp, char *buf, size_t size)
+{
+	struct fuse_chan *ch = *chp;
+	struct uvt_cdev *cdev = fuse_chan_data(ch);
+	struct fuse_session *se = fuse_chan_session(ch);
+	int fd = fuse_chan_fd(ch);
+	ssize_t res;
+
+	if (!se || !cdev)
+		return -EINVAL;
+
+	if (!size)
+		return 0;
+
+restart:
+	if (fuse_session_exited(se))
+		return 0;
+
+	res = read(fd, buf, size);
+	if (!res) {
+		/* EOF on cuse file */
+		llog_error(cdev, "fuse channel shut down on cdev %p", cdev);
+		fuse_session_exit(se);
+		return 0;
+	} else if (res < 0) {
+		/* ENOENT is returned if the operation was interrupted, it's
+		 * safe to restart */
+		if (errno == ENOENT)
+			goto restart;
+
+		/* ENODEV is returned if the FS got unmounted. This shouldn't
+		 * occur for CUSE devices. Anyway, exit if this happens. */
+		if (errno == ENODEV) {
+			llog_error(cdev, "fuse channel unmounted on cdev %p",
+				   cdev);
+			fuse_session_exit(se);
+			return 0;
+		}
+
+		/* EINTR and EAGAIN are simply forwarded to the caller. */
+		if (errno == EINTR || errno == EAGAIN)
+			return -errno;
+
+		cdev->error = -errno;
+		llog_error(cdev, "fuse channel read error on cdev %p (%d): %m",
+			   cdev, errno);
+		fuse_session_exit(se);
+		return cdev->error;
+	}
+
+	return res;
+}
+
+static int chan_send(struct fuse_chan *ch, const struct iovec iov[],
+		     size_t count)
+{
+	struct uvt_cdev *cdev = fuse_chan_data(ch);
+	struct fuse_session *se = fuse_chan_session(ch);
+	int fd = fuse_chan_fd(ch);
+	int ret;
+
+	if (!cdev || !se)
+		return -EINVAL;
+	if (!iov || !count)
+		return 0;
+
+	ret = writev(fd, iov, count);
+	if (ret < 0) {
+		/* ENOENT is returned on interrupts */
+		if (!fuse_session_exited(se) && errno != ENOENT) {
+			cdev->error = -errno;
+			llog_error(cdev, "cannot write to fuse-channel on cdev %p (%d): %m",
+				   cdev, errno);
+			fuse_session_exit(se);
+		}
+		return cdev->error;
+	}
+
+	return 0;
+}
+
+static const struct fuse_chan_ops chan_ops = {
+	.receive = chan_receive,
+	.send = chan_send,
+	.destroy = NULL,
+};
+
+/*
+ * Character Device
+ * This creates the high-level character-device driver and registers a
+ * fake-session that is used to control each character file.
+ * channel_event() is a callback when I/O is possible on the FUSE FD and
+ * performs all outstanding tasks.
+ * On error, the fake-session is unregistered and deleted. This also stops all
+ * client sessions, obviously.
+ */
+
+static void uvt_cdev_hup(struct uvt_cdev *cdev, int error)
+{
+	struct uvt_cdev_event ev;
+
+	ev_eloop_rm_fd(cdev->efd);
+	cdev->efd = NULL;
+	cdev->error = error;
+
+	memset(&ev, 0, sizeof(ev));
+	ev.type = UVT_CDEV_HUP;
+
+	shl_hook_call(cdev->hook, cdev, &ev);
+}
+
+static void channel_event(struct ev_fd *fd, int mask, void *data)
+{
+	struct uvt_cdev *cdev = data;
+	int ret;
+	struct fuse_buf buf;
+	struct fuse_chan *ch;
+	struct shl_dlist *iter;
+	struct uvt_client *client;
+
+	if (!(mask & EV_READABLE)) {
+		if (mask & (EV_HUP | EV_ERR)) {
+			llog_error(cdev, "HUP/ERR on fuse channel on cdev %p",
+				   cdev);
+			uvt_cdev_hup(cdev, -EPIPE);
+		}
+
+		return;
+	}
+
+	memset(&buf, 0, sizeof(buf));
+	buf.mem = cdev->buf;
+	buf.size = cdev->bufsize;
+	ch = cdev->channel;
+	ret = fuse_session_receive_buf(cdev->session, &buf, &ch);
+	if (ret == -EINTR || ret == -EAGAIN) {
+		return;
+	} else if (ret < 0) {
+		llog_error(cdev, "fuse channel read error on cdev %p: %d",
+			   cdev, ret);
+		uvt_cdev_hup(cdev, ret);
+		return;
+	}
+
+	fuse_session_process_buf(cdev->session, &buf, ch);
+	if (fuse_session_exited(cdev->session)) {
+		llog_error(cdev, "fuse session exited on cdev %p", cdev);
+		uvt_cdev_hup(cdev, cdev->error ? : -EFAULT);
+		return;
+	}
+
+	/* Readers can get interrupted asynchronously. Due to heavy locking
+	 * inside of FUSE, we cannot release them right away. So cleanup all
+	 * killed readers after we processed all buffers. */
+	shl_dlist_for_each(iter, &cdev->clients) {
+		client = shl_dlist_entry(iter, struct uvt_client, list);
+		uvt_client_cleanup(client);
+	}
+}
+
+static int uvt_cdev_init(struct uvt_cdev *cdev, const char *name,
+			 unsigned int major, unsigned int minor)
+{
+	const char *dev_info_argv[1];
+	struct cuse_info ci;
+	size_t bufsize;
+	char *nparam;
+	int ret;
+
+	/* TODO: libfuse makes sure that fd 0, 1 and 2 are available as
+	 * standard streams, otherwise they fail. This is awkward and we
+	 * should check whether this is really needed and _why_?
+	 * If it is needed, fix upstream to stop that crazy! */
+
+	if (!major)
+		major = TTY_MAJOR;
+
+	if (!major || major > 255) {
+		llog_error(cdev, "invalid major %u on cdev %p",
+			   major, cdev);
+		return -EINVAL;
+	}
+	if (!minor) {
+		llog_error(cdev, "invalid minor %u on cdev %p",
+			   minor, cdev);
+		return -EINVAL;
+	}
+	if (!name || !*name) {
+		llog_error(cdev, "empty name on cdev %p",
+			   cdev);
+		return -EINVAL;
+	}
+
+	llog_info(cdev, "creating device /dev/%s %u:%u on cdev %p",
+		  name, major, minor, cdev);
+
+	ret = asprintf(&nparam, "DEVNAME=%s", name);
+	if (ret <= 0)
+		return llog_ENOMEM(cdev);
+
+	dev_info_argv[0] = nparam;
+	memset(&ci, 0, sizeof(ci));
+	ci.dev_major = major;
+	ci.dev_minor = minor;
+	ci.dev_info_argc = 1;
+	ci.dev_info_argv = dev_info_argv;
+	ci.flags = CUSE_UNRESTRICTED_IOCTL;
+
+	cdev->session = cuse_lowlevel_new(NULL, &ci, &ll_ops, cdev);
+	free(nparam);
+
+	if (!cdev->session) {
+		llog_error(cdev, "cannot create fuse-ll session on cdev %p",
+			   cdev);
+		return -ENOMEM;
+	}
+
+	cdev->fd = open(cdev->ctx->cuse_file, O_RDWR | O_CLOEXEC | O_NONBLOCK);
+	if (cdev->fd < 0) {
+		llog_error(cdev, "cannot open cuse-file %s on cdev %p (%d): %m",
+			   cdev->ctx->cuse_file, cdev, errno);
+		ret = -EFAULT;
+		goto err_session;
+	}
+
+	bufsize = getpagesize() + 0x1000;
+	if (bufsize < 0x21000)
+		bufsize = 0x21000;
+
+	cdev->bufsize = bufsize;
+	cdev->buf = malloc(bufsize);
+	if (!cdev->buf) {
+		ret = llog_ENOMEM(cdev);
+		goto err_fd;
+	}
+
+	/* Argh! libfuse does not use "const" for the "chan_ops" pointer so we
+	 * actually have to cast it. Their implementation does not write into it
+	 * so we can safely use a constant storage for it.
+	 * TODO: Fix libfuse upstream! */
+	cdev->channel = fuse_chan_new((void*)&chan_ops, cdev->fd, bufsize,
+				      cdev);
+	if (!cdev->channel) {
+		llog_error(cdev, "cannot allocate fuse-channel on cdev %p",
+			   cdev);
+		ret = -ENOMEM;
+		goto err_buf;
+	}
+
+	ret = ev_eloop_new_fd(cdev->ctx->eloop, &cdev->efd, cdev->fd,
+			      EV_READABLE, channel_event, cdev);
+	if (ret)
+		goto err_chan;
+
+	fuse_session_add_chan(cdev->session, cdev->channel);
+	return 0;
+
+err_chan:
+	fuse_chan_destroy(cdev->channel);
+err_buf:
+	free(cdev->buf);
+err_fd:
+	close(cdev->fd);
+err_session:
+	fuse_session_destroy(cdev->session);
+	return ret;
+}
+
+static void uvt_cdev_destroy(struct uvt_cdev *cdev)
+{
+	if (cdev->error)
+		llog_warning(cdev, "cdev %p failed with error %d",
+			     cdev, cdev->error);
+
+	fuse_session_destroy(cdev->session);
+	ev_eloop_rm_fd(cdev->efd);
+	free(cdev->buf);
+	close(cdev->fd);
+}
+
+SHL_EXPORT
+int uvt_cdev_new(struct uvt_cdev **out, struct uvt_ctx *ctx,
+		 const char *name, unsigned int major, unsigned int minor)
+{
+	struct uvt_cdev *cdev;
+	int ret;
+
+	if (!ctx)
+		return -EINVAL;
+	if (!out)
+		return llog_EINVAL(ctx);
+
+	cdev = malloc(sizeof(*cdev));
+	if (!cdev)
+		return llog_ENOMEM(ctx);
+	memset(cdev, 0, sizeof(*cdev));
+	cdev->ref = 1;
+	cdev->ctx = ctx;
+	cdev->llog = ctx->llog;
+	cdev->llog_data = ctx->llog_data;
+	shl_dlist_init(&cdev->clients);
+
+	llog_debug(cdev, "new cdev %p on ctx %p", cdev, cdev->ctx);
+
+	ret = shl_hook_new(&cdev->hook);
+	if (ret)
+		goto err_free;
+
+	ret = uvt_cdev_init(cdev, name, major, minor);
+	if (ret)
+		goto err_hook;
+
+	uvt_ctx_ref(cdev->ctx);
+	*out = cdev;
+	return 0;
+
+err_hook:
+	shl_hook_free(cdev->hook);
+err_free:
+	free(cdev);
+	return ret;
+}
+
+SHL_EXPORT
+void uvt_cdev_ref(struct uvt_cdev *cdev)
+{
+	if (!cdev || !cdev->ref)
+		return;
+
+	++cdev->ref;
+}
+
+SHL_EXPORT
+void uvt_cdev_unref(struct uvt_cdev *cdev)
+{
+	if (!cdev || !cdev->ref || --cdev->ref)
+		return;
+
+	llog_debug(cdev, "free cdev %p", cdev);
+
+	uvt_cdev_destroy(cdev);
+	shl_hook_free(cdev->hook);
+	uvt_ctx_unref(cdev->ctx);
+	free(cdev);
+}
+
+SHL_EXPORT
+int uvt_cdev_register_cb(struct uvt_cdev *cdev, uvt_cdev_cb cb, void *data)
+{
+	if (!cdev)
+		return -EINVAL;
+
+	return shl_hook_add_cast(cdev->hook, cb, data, false);
+}
+
+SHL_EXPORT
+void uvt_cdev_unregister_cb(struct uvt_cdev *cdev, uvt_cdev_cb cb, void *data)
+{
+	if (!cdev)
+		return;
+
+	shl_hook_rm_cast(cdev->hook, cb, data);
+}