kernel: implement tty driver system

kernel/console.c

@@ -6,6 +6,20 @@
 static struct queue consoles;
 static spin_lock_t consoles_lock = SPIN_LOCK_INIT;
 
+static void unregister_boot_consoles(void)
+{
+	struct queue_entry *cur = queue_first(&consoles);
+	while (cur) {
+		struct queue_entry *next = cur->qe_next;
+		struct console *con = QUEUE_CONTAINER(struct console, c_list, cur);
+		if (con->c_flags & CON_BOOT) {
+			queue_delete(&consoles, cur);
+		}
+
+		cur = next;
+	}
+}
+
 kern_status_t console_register(struct console *con)
 {
 	unsigned long flags;
@@ -19,7 +33,13 @@ kern_status_t console_register(struct console *con)
 	}
 
 	queue_push_back(&consoles, &con->c_list);
+
+	if (!(con->c_flags & CON_BOOT)) {
+		unregister_boot_consoles();
+	}
+
 	spin_unlock_irqrestore(&consoles_lock, flags);
+
 	return KERN_OK;
 }
 

kernel/tty.c

@@ -1,13 +0,0 @@
-#include <socks/tty.h>
-#include <socks/locks.h>
-#include <socks/queue.h>
-
-int tty_read(struct tty *tty, char *s, unsigned long len)
-{
-	return 0;
-}
-
-int tty_write(struct tty *tty, const char *s, unsigned long len)
-{
-	return 0;
-}

kernel/tty/device.c

@@ -0,0 +1,42 @@
+#include <socks/tty.h>
+#include <socks/device.h>
+#include <socks/libc/stdio.h>
+
+struct device *tty_device_create(void)
+{
+	struct char_device *cdev = char_device_create();
+	if (!cdev) {
+		return NULL;
+	}
+
+	struct tty_device *tty_dev = kmalloc(sizeof *tty_dev, VM_NORMAL);
+	if (!tty_dev) {
+		/* TODO destroy cdev */
+		return NULL;
+	}
+
+	cdev->c_tty = tty_dev;
+	return char_device_base(cdev);
+}
+
+static kern_status_t generate_name(struct tty_driver *owner, struct device *dev, char out[DEV_NAME_MAX])
+{
+	/* minor numbers start at 1. subtract 1 to start at 0 instead */
+	snprintf(out, DEV_NAME_MAX, "%s%u", owner->tty_name, dev->dev_minor - 1);
+	return KERN_OK;
+}
+
+kern_status_t tty_device_register(struct device *dev, struct tty_driver *owner, struct device *parent)
+{
+	kern_status_t status = device_register(dev, tty_driver_base(owner), parent);
+	if (status != KERN_OK) {
+		return status;
+	}
+
+	char link_name[DEV_NAME_MAX];
+	generate_name(owner, dev, link_name);
+	char link_path[OBJECT_PATH_MAX];
+	snprintf(link_path, sizeof link_path, "/dev/tty/%s", link_name);
+
+	return object_namespace_create_link(global_namespace(), link_path, &dev->dev_base);
+}

kernel/tty/driver.c

@@ -0,0 +1,71 @@
+#include <socks/tty.h>
+
+static struct vm_cache tty_driver_cache = {
+	.c_name = "tty_driver",
+	.c_obj_size = sizeof(struct tty_driver),
+};
+
+static struct queue tty_drivers;
+static spin_lock_t tty_drivers_lock;
+
+kern_status_t tty_init(void)
+{
+	vm_cache_init(&tty_driver_cache);
+	tty_drivers = QUEUE_INIT;
+	tty_drivers_lock = SPIN_LOCK_INIT;
+
+	return KERN_OK;
+}
+
+struct tty_driver *tty_driver_create(struct kext *self, const char *name)
+{
+	struct tty_driver *driver = vm_cache_alloc(&tty_driver_cache, VM_NORMAL);
+	if (!driver) {
+		return NULL;
+	}
+
+	kern_status_t status = driver_init(&driver->tty_base, self, name);
+	if (status != KERN_OK) {
+		vm_cache_free(&tty_driver_cache, driver);
+		return NULL;
+	}
+
+	strncpy(driver->tty_name, name, sizeof driver->tty_name - 1);
+
+	return driver;
+}
+
+kern_status_t tty_driver_destroy(struct tty_driver *driver)
+{
+	/* TODO */
+	return KERN_UNIMPLEMENTED;
+}
+
+kern_status_t tty_driver_register(struct tty_driver *driver)
+{
+	kern_status_t status = driver_register(&driver->tty_base);
+	if (status != KERN_OK) {
+		return status;
+	}
+
+	unsigned long flags;
+	spin_lock_irqsave(&tty_drivers_lock, &flags);
+	queue_push_back(&tty_drivers, &driver->tty_head);
+	spin_unlock_irqrestore(&tty_drivers_lock, flags);
+
+	return KERN_OK;
+}
+
+kern_status_t tty_driver_unregister(struct tty_driver *driver)
+{
+	if (driver->tty_base.drv_major == DEV_MAJOR_INVALID) {
+		return KERN_INVALID_ARGUMENT;
+	}
+
+	unsigned long flags;
+	spin_lock_irqsave(&tty_drivers_lock, &flags);
+	queue_delete(&tty_drivers, &driver->tty_head);
+	spin_unlock_irqrestore(&tty_drivers_lock, flags);
+
+	return driver_unregister(&driver->tty_base);
+}