vfs: Add devtmpfs + memfiles

2026-10-25 18:45:38 +01:00
parent d14f895288
commit c0767b4631
7 changed files with 300 additions and 0 deletions
@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: ISC
+
+#include <zinnia/chardev.h>
+
+void chardev_init(
+    struct chardev* dev,
+    const struct chardev_ops* ops,
+    const struct vfs_file_ops* file_ops,
+    uint32_t major,
+    uint32_t minor
+) {
+    refcount_init(&dev->rc);
+    dev->ops = ops;
+    dev->file_ops = file_ops;
+    dev->dev = dev_make(major, minor);
+}
+
+void chardev_ref(struct chardev* dev) {
+    refcount_inc(&dev->rc);
+}
+
+void chardev_unref(struct chardev* dev) {
+    if (refcount_dec(&dev->rc) && dev->ops && dev->ops->destroy)
+        dev->ops->destroy(dev);
+}
+
+static errno_t chardev_node_open(struct vfs_node* node, struct vfs_file* file) {
+    struct chardev* dev = node->priv;
+    file->ops = dev->file_ops;
+    if (dev->ops && dev->ops->open)
+        return dev->ops->open(dev, file);
+    return 0;
+}
+
+static void chardev_node_destroy(struct vfs_node* node) {
+    chardev_unref(node->priv);
+}
+
+static const struct vfs_node_ops chardev_node_ops = {
+    .destroy = chardev_node_destroy,
+    .device = {
+        .open = chardev_node_open,
+    },
+};
+
+errno_t devtmpfs_add_chardev(const char* name, struct chardev* dev, mode_t mode) {
+    struct vfs_mknod_target target = {
+        .type = VNODE_CHARDEV,
+        .ops = &chardev_node_ops,
+        .priv = dev,
+        .rdev = dev->dev,
+    };
+
+    chardev_ref(dev);
+    struct vfs_path root = devtmpfs_root();
+    errno_t status = vfs_mknod(root, root, name, mode, &target, ident_kernel(), nullptr);
+    vfs_path_drop(root);
+    if (status)
+        chardev_unref(dev);
+    return status;
+}
+
+errno_t devtmpfs_mkdir(const char* name, mode_t mode) {
+    struct vfs_path root = devtmpfs_root();
+    errno_t status = vfs_mkdir(root, root, name, mode, ident_kernel());
+    vfs_path_drop(root);
+    return status;
+}
+
+errno_t devtmpfs_remove(const char* name) {
+    struct vfs_path root = devtmpfs_root();
+    errno_t status = vfs_unlink(root, root, name, ident_kernel());
+    vfs_path_drop(root);
+    return status;
+}
+
+errno_t devtmpfs_symlink(const char* name, const char* target) {
+    struct vfs_path root = devtmpfs_root();
+    errno_t status = vfs_symlink(root, root, name, target, ident_kernel());
+    vfs_path_drop(root);
+    return status;
+}
@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: ISC
+
+#include <zinnia/assert.h>
+#include <zinnia/chardev.h>
+#include <zinnia/random.h>
+#include <zinnia/utils.h>
+
+constexpr size_t MEMFILE_CHUNK = 64;
+
+static const uint8_t zero_chunk[MEMFILE_CHUNK];
+
+static errno_t memfile_discard(struct vfs_file* file, iovec_iter_t* buffer, uint64_t offset, ssize_t* out_written) {
+    *out_written = iovec_iter_len(buffer);
+    return 0;
+}
+
+static errno_t memfile_read_zero(struct vfs_file* file, iovec_iter_t* buffer, uint64_t offset, ssize_t* out_read) {
+    size_t total = 0;
+    errno_t status = 0;
+    while (iovec_iter_len(buffer)) {
+        size_t copied;
+        status = iovec_iter_copy_to(buffer, zero_chunk, MIN(iovec_iter_len(buffer), MEMFILE_CHUNK), &copied);
+        total += copied;
+        if (status)
+            break;
+    }
+    *out_read = total;
+    return status;
+}
+
+static errno_t null_read(struct vfs_file* file, iovec_iter_t* buffer, uint64_t offset, ssize_t* out_read) {
+    *out_read = 0;
+    return 0;
+}
+
+static const struct vfs_file_ops null_file_ops = {
+    .read = null_read,
+    .write = memfile_discard,
+};
+
+static const struct vfs_file_ops zero_file_ops = {
+    .read = memfile_read_zero,
+    .write = memfile_discard,
+};
+
+static errno_t full_write(struct vfs_file* file, iovec_iter_t* buffer, uint64_t offset, ssize_t* out_written) {
+    *out_written = 0;
+    return ENOSPC;
+}
+
+static const struct vfs_file_ops full_file_ops = {
+    .read = memfile_read_zero,
+    .write = full_write,
+};
+
+static errno_t random_read(struct vfs_file* file, iovec_iter_t* buffer, uint64_t offset, ssize_t* out_read) {
+    uint8_t chunk[MEMFILE_CHUNK];
+    size_t total = 0;
+    errno_t status = 0;
+    while (iovec_iter_len(buffer)) {
+        const size_t len = MIN(iovec_iter_len(buffer), sizeof(chunk));
+
+        // TODO: This function sucks and is probably not useful for cryptography.
+        random_fill(chunk, len);
+
+        size_t copied;
+        status = iovec_iter_copy_to(buffer, chunk, len, &copied);
+        total += copied;
+        if (status)
+            break;
+    }
+    *out_read = total;
+    return status;
+}
+
+static const struct vfs_file_ops random_file_ops = {
+    .read = random_read,
+    .write = memfile_discard,
+};
+
+static struct chardev null_dev;
+static struct chardev zero_dev;
+static struct chardev full_dev;
+static struct chardev random_dev;
+static struct chardev urandom_dev;
+
+static void memfiles_add(const char* name, struct chardev* dev, const struct vfs_file_ops* ops, uint32_t minor) {
+    chardev_init(dev, nullptr, ops, 1, minor);
+    errno_t status = devtmpfs_add_chardev(name, dev, 0666);
+    assert(status == 0, "Unable to create /dev/%s (%i)", name, status);
+}
+
+static void memfiles_stage_init(struct boot_info* info) {
+    memfiles_add("null", &null_dev, &null_file_ops, 3);
+    memfiles_add("zero", &zero_dev, &zero_file_ops, 5);
+    memfiles_add("full", &full_dev, &full_file_ops, 7);
+    memfiles_add("random", &random_dev, &random_file_ops, 8);
+    memfiles_add("urandom", &urandom_dev, &random_file_ops, 9);
+}
+
+INIT_TASK(memfiles_stage, "dev.memfiles", memfiles_stage_init);
+INIT_DEPENDS(memfiles_stage, devtmpfs_stage, random_stage);
@@ -0,0 +1,4 @@
+kernel_sources += files(
+    'chardev.c',
+    'memfiles.c',
+)
@@ -1,4 +1,5 @@
 subdir('block')
+subdir('char')
 subdir('dt')
 subdir('video')

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: ISC
+
+#include <zinnia/assert.h>
+#include <zinnia/chardev.h>
+#include <zinnia/ident.h>
+#include <zinnia/vfs.h>
+
+static struct vfs_mount* dev_mount;
+
+struct vfs_path devtmpfs_root() {
+    return vfs_path_clone((struct vfs_path){.mount = dev_mount, .entry = dev_mount->root});
+}
+
+static errno_t devtmpfs_mount(
+    const struct vfs_filesystem* fs,
+    enum mount_flags flags,
+    void* arg,
+    struct vfs_mount** out
+) {
+    return vfs_mount_new(flags, dev_mount->root, out);
+}
+
+static const struct vfs_filesystem devtmpfs = {
+    .name = "devtmpfs",
+    .mount = devtmpfs_mount,
+};
+
+static void devtmpfs_stage_init(struct boot_info* info) {
+    errno_t status = vfs_mount("tmpfs", 0, nullptr, &dev_mount);
+    assert(status == 0, "Unable to create the devtmpfs (%i)", status);
+
+    status = vfs_register_filesystem(&devtmpfs);
+    assert(status == 0, "Unable to register the devtmpfs (%i)", status);
+}
+
+INIT_TASK(devtmpfs_stage, "fs.devtmpfs", devtmpfs_stage_init);
+INIT_DEPENDS(devtmpfs_stage, vfs_stage);
+
+static void devtmpfs_mount_stage_init(struct boot_info* info) {
+    // Create /dev.
+    struct vfs_path root = vfs_get_root();
+    errno_t status = vfs_mkdir(root, root, "/dev", 0755, ident_kernel());
+    assert(status == 0 || status == EEXIST, "Unable to create /dev (%i)", status);
+
+    // Get /dev.
+    struct vfs_path target;
+    status = vfs_path_lookup(root, root, "/dev", ident_kernel(), VFS_LOOKUP_MUST_EXIST, &target);
+    vfs_path_drop(root);
+    assert(status == 0, "Unable to look up /dev (%i)", status);
+
+    // Prepare a devtmpfs for mounting.
+    struct vfs_mount* mount;
+    status = vfs_mount("devtmpfs", 0, nullptr, &mount);
+    assert(status == 0, "Unable to mount the devtmpfs (%i)", status);
+
+    // Mount it on /dev.
+    status = vfs_path_mount(target, mount);
+    assert(status == 0, "Unable to mount the devtmpfs on /dev (%i)", status);
+    vfs_mount_unref(mount);
+    vfs_path_drop(target);
+}
+
+INIT_TASK(devtmpfs_mount_stage, "fs.devtmpfs.mount", devtmpfs_mount_stage_init);
+INIT_DEPENDS(devtmpfs_mount_stage, devtmpfs_stage);
@@ -1,6 +1,7 @@
 kernel_sources += files(
    'anon.c',
    'cache.c',
+    'devtmpfs.c',
    'file.c',
    'ident.c',
    'init.c',
@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: ISC
+
+#pragma once
+
+#include <zinnia/errno.h>
+#include <zinnia/initgraph.h>
+#include <zinnia/refcount.h>
+#include <zinnia/types.h>
+#include <zinnia/vfs.h>
+#include <stdint.h>
+
+static inline dev_t dev_make(uint32_t major, uint32_t minor) {
+    return (minor & 0xFF) | ((major & 0xFFF) << 8) | ((dev_t)(minor & ~0xFFU) << 12) | ((dev_t)(major & ~0xFFFU) << 32);
+}
+
+struct chardev;
+
+struct chardev_ops {
+    errno_t (*open)(struct chardev* dev, struct vfs_file* file);
+    void (*destroy)(struct chardev* dev);
+};
+
+struct chardev {
+    struct refcount rc;
+    const struct chardev_ops* ops;
+    const struct vfs_file_ops* file_ops;
+    dev_t dev;
+};
+
+void chardev_init(
+    struct chardev* dev,
+    const struct chardev_ops* ops,
+    const struct vfs_file_ops* file_ops,
+    uint32_t major,
+    uint32_t minor
+);
+void chardev_ref(struct chardev* dev);
+void chardev_unref(struct chardev* dev);
+
+struct vfs_path devtmpfs_root();
+errno_t devtmpfs_add_chardev(const char* name, struct chardev* dev, mode_t mode);
+errno_t devtmpfs_mkdir(const char* name, mode_t mode);
+errno_t devtmpfs_remove(const char* name);
+errno_t devtmpfs_symlink(const char* name, const char* target);
+
+INIT_EXTERN(devtmpfs_stage);