apps/CMakeLists.txt

@@ -24,5 +24,3 @@ luna_app(uname.cpp uname)
 luna_app(base64.cpp base64)
 luna_app(login.cpp login)
 luna_app(ipc-test.cpp ipc-test)
-luna_app(mount.cpp mount)
-luna_app(umount.cpp umount)

apps/init.cpp

@@ -18,6 +18,21 @@
 
 FILE* g_init_log;
 
+#define xmknod(path, mode, maj, min)                                                                                   \
+    if (mknod(path, mode, makedev(maj, min)) < 0) exit(255);
+
+// Too early for console logs (/dev/console is created here!), so we have to resort to exiting with a weird exit code in
+// case of failure.
+static void populate_devfs()
+{
+    if (mkdir("/dev", 0755) < 0 && errno != EEXIST) exit(255);
+
+    xmknod("/dev/console", 0666, 1, 0);
+    xmknod("/dev/null", 0666, 2, 0);
+    xmknod("/dev/zero", 0666, 2, 1);
+    xmknod("/dev/fb0", 0222, 3, 0);
+}
+
 struct Service
 {
     String name;
@@ -266,6 +281,8 @@ int main()
         return 1;
     }
 
+    populate_devfs();
+
     // Before this point, we don't even have an stdin, stdout and stderr. Set it up now so that child processes (and us)
     // can print stuff.
     stdin = fopen("/dev/console", "r");

apps/mount.cpp

@@ -1,24 +0,0 @@
-#include <os/ArgumentParser.h>
-#include <stdio.h>
-#include <sys/mount.h>
-
-Result<int> luna_main(int argc, char** argv)
-{
-    StringView target;
-    StringView fstype;
-
-    os::ArgumentParser parser;
-    parser.add_description("Mount a file system.");
-    parser.add_system_program_info("mount"_sv);
-    parser.add_positional_argument(target, "mountpoint"_sv, true);
-    parser.add_value_argument(fstype, 't', "type"_sv, "auto"_sv, "the file system type to use");
-    parser.parse(argc, argv);
-
-    if (mount(target.chars(), fstype.chars()) < 0)
-    {
-        perror("mount");
-        return 1;
-    }
-
-    return 0;
-}

apps/umount.cpp

@@ -1,22 +0,0 @@
-#include <os/ArgumentParser.h>
-#include <stdio.h>
-#include <sys/mount.h>
-
-Result<int> luna_main(int argc, char** argv)
-{
-    StringView target;
-
-    os::ArgumentParser parser;
-    parser.add_description("Unmount a file system.");
-    parser.add_system_program_info("umount"_sv);
-    parser.add_positional_argument(target, "mountpoint"_sv, true);
-    parser.parse(argc, argv);
-
-    if (umount(target.chars()) < 0)
-    {
-        perror("umount");
-        return 1;
-    }
-
-    return 0;
-}

kernel/CMakeLists.txt

@@ -38,10 +38,8 @@ set(SOURCES
     src/sys/chdir.cpp
     src/sys/link.cpp
     src/sys/uname.cpp
-    src/sys/mount.cpp
     src/fs/VFS.cpp
     src/fs/Pipe.cpp
-    src/fs/Mount.cpp
     src/fs/tmpfs/FileSystem.cpp
     src/fs/devices/DeviceRegistry.cpp
     src/fs/devices/NullDevice.cpp

kernel/src/fs/Mount.cpp

@@ -1,19 +0,0 @@
-#include "fs/Mount.h"
-
-LinkedList<MountInode> g_mounts;
-
-Result<SharedPtr<VFS::Inode>> MountInode::create(SharedPtr<VFS::Inode> source, SharedPtr<VFS::FileSystem> fs)
-{
-    auto inode = TRY(adopt_shared_if_nonnull(new (std::nothrow) MountInode()));
-
-    inode->m_source = source;
-    inode->m_mountee = fs;
-    inode->m_mount_root_inode = fs->root_inode();
-
-    auto parent = TRY(source->find(".."));
-    TRY(fs->set_mount_dir(parent));
-
-    g_mounts.append(inode.ptr());
-
-    return (SharedPtr<VFS::Inode>)inode;
-}

kernel/src/fs/Mount.h

@@ -1,150 +0,0 @@
-#pragma once
-#include "fs/VFS.h"
-#include <luna/LinkedList.h>
-
-class MountInode : public VFS::Inode, public LinkedListNode<MountInode>
-{
-  public:
-    static Result<SharedPtr<VFS::Inode>> create(SharedPtr<VFS::Inode> source, SharedPtr<VFS::FileSystem> fs);
-
-    void set_fs(SharedPtr<VFS::FileSystem> fs)
-    {
-        m_mountee = fs;
-    }
-
-    Result<SharedPtr<VFS::Inode>> find(const char* name) const override
-    {
-        return m_mount_root_inode->find(name);
-    }
-
-    Option<VFS::DirectoryEntry> get(usize index) const override
-    {
-        return m_mount_root_inode->get(index);
-    }
-
-    Result<usize> read(u8*, usize, usize) const override
-    {
-        return err(EISDIR);
-    }
-
-    Result<usize> write(const u8*, usize, usize) override
-    {
-        return err(EISDIR);
-    }
-
-    Result<void> truncate(usize) override
-    {
-        return err(EISDIR);
-    }
-
-    bool blocking() const override
-    {
-        return false;
-    }
-
-    usize size() const override
-    {
-        return 0;
-    }
-
-    mode_t mode() const override
-    {
-        return m_mount_root_inode->mode();
-    }
-
-    u32 uid() const override
-    {
-        return m_mount_root_inode->uid();
-    }
-
-    u32 gid() const override
-    {
-        return m_mount_root_inode->gid();
-    }
-
-    Result<void> chmod(mode_t mode) override
-    {
-        return m_mount_root_inode->chmod(mode);
-    }
-
-    Result<void> chown(u32 uid, u32 gid) override
-    {
-        return m_mount_root_inode->chown(uid, gid);
-    }
-
-    VFS::FileSystem* fs() const override
-    {
-        return m_mountee.ptr();
-    }
-
-    usize inode_number() const override
-    {
-        return m_mount_root_inode->inode_number();
-    }
-
-    VFS::InodeType type() const override
-    {
-        return VFS::InodeType::Directory;
-    }
-
-    void did_link() override
-    {
-        m_mount_root_inode->did_link();
-    }
-
-    void did_unlink() override
-    {
-        m_mount_root_inode->did_unlink();
-    }
-
-    usize entries() const override
-    {
-        return m_mount_root_inode->entries();
-    }
-
-    bool is_mountpoint() const override
-    {
-        return true;
-    }
-
-    SharedPtr<VFS::Inode> source() const
-    {
-        return m_source;
-    }
-
-    Result<void> remove_entry(const char* name) override
-    {
-        return m_mount_root_inode->remove_entry(name);
-    }
-
-    Result<SharedPtr<VFS::Inode>> create_file(const char* name) override
-    {
-        return m_mount_root_inode->create_file(name);
-    }
-
-    Result<SharedPtr<VFS::Inode>> create_subdirectory(const char* name) override
-    {
-        return m_mount_root_inode->create_subdirectory(name);
-    }
-
-    Result<void> add_entry(SharedPtr<VFS::Inode> inode, const char* name) override
-    {
-        return m_mount_root_inode->add_entry(inode, name);
-    }
-
-    Result<void> replace_entry(SharedPtr<VFS::Inode> inode, const char* name) override
-    {
-        return m_mount_root_inode->replace_entry(inode, name);
-    }
-
-    virtual ~MountInode() = default;
-
-  private:
-    SharedPtr<VFS::Inode> m_source;
-    SharedPtr<VFS::FileSystem> m_mountee;
-    SharedPtr<VFS::Inode> m_mount_root_inode;
-
-    MountInode() = default;
-};
-
-extern LinkedList<MountInode> g_mounts;

kernel/src/fs/VFS.cpp

@@ -1,6 +1,5 @@
 #include "fs/VFS.h"
 #include "Log.h"
-#include "fs/Mount.h"
 #include "thread/Thread.h"
 #include <bits/modes.h>
 #include <luna/PathParser.h>
@@ -98,8 +97,6 @@ namespace VFS
 
     bool can_execute(SharedPtr<Inode> inode, Credentials auth)
     {
-        if (auth.euid == 0) return true;
-
         if (inode->uid() == auth.euid) { return inode->mode() & S_IXUSR; }
         if (inode->gid() == auth.egid) { return inode->mode() & S_IXGRP; }
 
@@ -108,8 +105,6 @@ namespace VFS
 
     bool can_write(SharedPtr<Inode> inode, Credentials auth)
     {
-        if (auth.euid == 0) return true;
-
         if (inode->uid() == auth.euid) { return inode->mode() & S_IWUSR; }
         if (inode->gid() == auth.egid) { return inode->mode() & S_IWGRP; }
 
@@ -118,8 +113,6 @@ namespace VFS
 
     bool can_read(SharedPtr<Inode> inode, Credentials auth)
     {
-        if (auth.euid == 0) return true;
-
         if (inode->uid() == auth.euid) { return inode->mode() & S_IRUSR; }
         if (inode->gid() == auth.egid) { return inode->mode() & S_IRGRP; }
 
@@ -135,55 +128,4 @@ namespace VFS
     {
         return inode->mode() & S_ISGID;
     }
-
-    Result<void> mount_root(SharedPtr<VFS::FileSystem> fs)
-    {
-        root_fs = fs;
-
-        return {};
-    }
-
-    Result<void> mount(const char* path, SharedPtr<VFS::FileSystem> fs, Credentials auth,
-                       SharedPtr<VFS::Inode> working_directory)
-    {
-        auto parser = TRY(PathParser::create(path));
-        auto parent_path = TRY(parser.dirname());
-        auto child = TRY(parser.basename());
-
-        kdbgln("vfs: Mounting filesystem on target %s", path);
-
-        auto parent_inode = TRY(resolve_path(parent_path.chars(), auth, working_directory));
-
-        auto inode = TRY(parent_inode->find(child.chars()));
-        if (inode->type() != VFS::InodeType::Directory) return err(ENOTDIR);
-        if (inode->is_mountpoint()) return err(EBUSY);
-
-        auto mount = TRY(MountInode::create(inode, fs));
-
-        TRY(parent_inode->replace_entry(mount, child.chars()));
-
-        return {};
-    }
-
-    Result<void> umount(const char* path, Credentials auth, SharedPtr<VFS::Inode> working_directory)
-    {
-        auto parser = TRY(PathParser::create(path));
-        auto parent_path = TRY(parser.dirname());
-        auto child = TRY(parser.basename());
-
-        kdbgln("vfs: Unmounting filesystem on target %s", path);
-
-        auto parent_inode = TRY(resolve_path(parent_path.chars(), auth, working_directory));
-
-        auto inode = TRY(parent_inode->find(child.chars()));
-        if (!inode->is_mountpoint()) return err(EINVAL);
-
-        // There are still open file descriptors referencing files within this file system.
-        if (inode->fs()->handles() != 0) return err(EBUSY);
-
-        auto mount = (MountInode*)inode.ptr();
-        TRY(parent_inode->replace_entry(mount->source(), child.chars()));
-
-        return {};
-    }
 }

kernel/src/fs/VFS.h

@@ -46,8 +46,6 @@ namespace VFS
 
         virtual Result<void> remove_entry(const char* name) = 0;
 
-        virtual Result<void> replace_entry(SharedPtr<Inode> inode, const char* name) = 0;
-
         virtual usize entries() const = 0;
 
         // File-specific methods
@@ -74,11 +72,6 @@ namespace VFS
             return 0;
         }
 
-        virtual bool is_mountpoint() const
-        {
-            return false;
-        }
-
         virtual void did_link() = 0;
         virtual void did_unlink() = 0;
 
@@ -125,11 +118,6 @@ namespace VFS
             return err(ENOTDIR);
         }
 
-        Result<void> replace_entry(SharedPtr<Inode>, const char*) override
-        {
-            return err(ENOTDIR);
-        }
-
         Result<void> remove_entry(const char*) override
         {
             return err(ENOTDIR);
@@ -181,11 +169,6 @@ namespace VFS
             return err(ENOTDIR);
         }
 
-        Result<void> replace_entry(SharedPtr<Inode>, const char*) override
-        {
-            return err(ENOTDIR);
-        }
-
         Result<void> remove_entry(const char*) override
         {
             return err(ENOTDIR);
@@ -215,29 +198,11 @@ namespace VFS
 
         virtual Result<SharedPtr<Inode>> create_device_inode(u32 major, u32 minor) = 0;
 
-        virtual Result<void> set_mount_dir(SharedPtr<Inode> parent) = 0;
-
-        virtual u64 handles() const
-        {
-            return m_handles;
-        }
-
-        virtual void add_handle()
-        {
-            m_handles++;
-        }
-
-        virtual void remove_handle()
-        {
-            m_handles--;
-        }
-
         virtual ~FileSystem() = default;
-
-      protected:
-        u64 m_handles { 0 };
     };
 
+    extern SharedPtr<FileSystem> root_fs;
+
     Result<SharedPtr<Inode>> resolve_path(const char* path, Credentials auth,
                                           SharedPtr<VFS::Inode> working_directory = {});
 
@@ -256,10 +221,4 @@ namespace VFS
     bool is_setgid(SharedPtr<Inode> inode);
 
     Inode& root_inode();
-
-    Result<void> mount_root(SharedPtr<VFS::FileSystem> fs);
-    Result<void> mount(const char* path, SharedPtr<VFS::FileSystem> fs, Credentials auth,
-                       SharedPtr<Inode> working_directory = {});
-
-    Result<void> umount(const char* path, Credentials auth, SharedPtr<Inode> working_directory = {});
 }

kernel/src/fs/devices/ConsoleDevice.cpp

@@ -18,7 +18,7 @@ static bool g_echo { true };
 Result<void> ConsoleDevice::create()
 {
     auto device = (SharedPtr<Device>)TRY(make_shared<ConsoleDevice>());
-    return DeviceRegistry::register_special_device(DeviceRegistry::Console, 0, device, "console");
+    return DeviceRegistry::register_special_device(DeviceRegistry::Console, 0, device);
 }
 
 Result<usize> ConsoleDevice::read(u8* buf, usize, usize length) const

kernel/src/fs/devices/DeviceRegistry.cpp

@@ -1,12 +1,9 @@
 #include "fs/devices/DeviceRegistry.h"
 #include "Log.h"
-#include "fs/VFS.h"
 #include "fs/devices/ConsoleDevice.h"
 #include "fs/devices/FramebufferDevice.h"
 #include "fs/devices/NullDevice.h"
 #include "fs/devices/ZeroDevice.h"
-#include "fs/tmpfs/FileSystem.h"
-#include "thread/Thread.h"
 #include <luna/Vector.h>
 
 struct DeviceDescriptor
@@ -14,14 +11,10 @@ struct DeviceDescriptor
     SharedPtr<Device> device;
     u32 major;
     u32 minor;
-    const char* name;
-    mode_t mode;
 };
 
 Vector<DeviceDescriptor> g_available_devices = {};
 
-SharedPtr<VFS::FileSystem> g_device_fs;
-
 namespace DeviceRegistry
 {
     Result<SharedPtr<Device>> fetch_special_device(u32 major, u32 minor)
@@ -34,39 +27,20 @@ namespace DeviceRegistry
         return err(ENODEV);
     }
 
-    Result<void> create_special_device_inode(DeviceDescriptor& descriptor)
+    Result<void> register_special_device(u32 major, u32 minor, SharedPtr<Device> device)
-    {
-        auto inode = TRY(g_device_fs->create_device_inode(descriptor.major, descriptor.minor));
-        inode->chmod(descriptor.mode);
-        TRY(g_device_fs->root_inode()->add_entry(inode, descriptor.name));
-
-        return {};
-    }
-
-    Result<void> register_special_device(u32 major, u32 minor, SharedPtr<Device> device, const char* name, mode_t mode)
     {
         for (const auto& descriptor : g_available_devices)
         {
             if (descriptor.major == major && descriptor.minor == minor) return err(EEXIST);
         }
 
-        kdbgln("DeviceRegistry: registered new device type %u:%u at path /dev/%s", major, minor, name);
+        kdbgln("DeviceRegistry: registered new device type %u:%u", major, minor);
 
-        auto desc = DeviceDescriptor { .device = device, .major = major, .minor = minor, .name = name, .mode = mode };
+        return g_available_devices.try_append(DeviceDescriptor { .device = device, .major = major, .minor = minor });
-
-        TRY(g_available_devices.try_append(desc));
-
-        TRY(create_special_device_inode(desc));
-
-        return {};
     }
 
     Result<void> init()
     {
-        auto device_fs = TRY(TmpFS::FileSystem::create());
-        TRY(VFS::mount("/dev", device_fs, Credentials {}));
-        g_device_fs = device_fs;
-
         NullDevice::create();
         ZeroDevice::create();
         ConsoleDevice::create();

kernel/src/fs/devices/DeviceRegistry.h

@@ -2,7 +2,6 @@
 
 #include "fs/devices/Device.h"
 #include <luna/SharedPtr.h>
-#include <sys/types.h>
 
 namespace DeviceRegistry
 {
@@ -16,8 +15,7 @@ namespace DeviceRegistry
 
     Result<SharedPtr<Device>> fetch_special_device(u32 major, u32 minor);
 
-    Result<void> register_special_device(u32 major, u32 minor, SharedPtr<Device> device, const char* name,
+    Result<void> register_special_device(u32 major, u32 minor, SharedPtr<Device> device);
-                                         mode_t mode = 0666);
 
     Result<void> init();
 }

kernel/src/fs/devices/FramebufferDevice.cpp

@@ -6,7 +6,7 @@
 Result<void> FramebufferDevice::create()
 {
     auto device = (SharedPtr<Device>)TRY(make_shared<FramebufferDevice>());
-    return DeviceRegistry::register_special_device(DeviceRegistry::Framebuffer, 0, device, "fb0", 0600);
+    return DeviceRegistry::register_special_device(DeviceRegistry::Framebuffer, 0, device);
 }
 
 Result<usize> FramebufferDevice::read(u8*, usize, usize) const

kernel/src/fs/devices/NullDevice.cpp

@@ -3,5 +3,5 @@
 Result<void> NullDevice::create()
 {
     auto device = (SharedPtr<Device>)TRY(make_shared<NullDevice>());
-    return DeviceRegistry::register_special_device(DeviceRegistry::Memory, 0, device, "null");
+    return DeviceRegistry::register_special_device(DeviceRegistry::Memory, 0, device);
 }

kernel/src/fs/devices/ZeroDevice.cpp

@@ -3,5 +3,5 @@
 Result<void> ZeroDevice::create()
 {
     auto device = (SharedPtr<Device>)TRY(make_shared<ZeroDevice>());
-    return DeviceRegistry::register_special_device(DeviceRegistry::Memory, 1, device, "zero");
+    return DeviceRegistry::register_special_device(DeviceRegistry::Memory, 1, device);
 }

kernel/src/fs/tmpfs/FileSystem.cpp

@@ -1,5 +1,4 @@
 #include "fs/tmpfs/FileSystem.h"
-#include "fs/Mount.h"
 #include "fs/devices/DeviceRegistry.h"
 #include <luna/Alloc.h>
 #include <luna/CString.h>
@@ -50,11 +49,6 @@ namespace TmpFS
         return (SharedPtr<VFS::Inode>)inode;
     }
 
-    Result<void> FileSystem::set_mount_dir(SharedPtr<VFS::Inode> parent)
-    {
-        return m_root_inode->replace_entry(parent, "..");
-    }
-
     void FileSystem::set_root(SharedPtr<VFS::Inode> root)
     {
         m_root_inode = root;
@@ -70,20 +64,6 @@ namespace TmpFS
         return err(ENOENT);
     }
 
-    Result<void> DirInode::replace_entry(SharedPtr<VFS::Inode> inode, const char* name)
-    {
-        for (auto& entry : m_entries)
-        {
-            if (!strcmp(name, entry.name.chars()))
-            {
-                entry.inode = inode;
-                return {};
-            }
-        }
-
-        return err(ENOENT);
-    }
-
     Option<VFS::DirectoryEntry> DirInode::get(usize index) const
     {
         if (index >= m_entries.size()) return {};
@@ -110,8 +90,6 @@ namespace TmpFS
 
         if (inode->type() == VFS::InodeType::Directory && inode->entries() != 2) return err(ENOTEMPTY);
 
-        if (inode->is_mountpoint()) return err(EBUSY);
-
         m_entries.remove_first_matching(
             [&](const VFS::DirectoryEntry& entry) { return !strcmp(entry.name.chars(), name); });
 

kernel/src/fs/tmpfs/FileSystem.h

@@ -21,8 +21,6 @@ namespace TmpFS
         Result<SharedPtr<VFS::Inode>> create_dir_inode(SharedPtr<VFS::Inode> parent) override;
         Result<SharedPtr<VFS::Inode>> create_device_inode(u32 major, u32 minor) override;
 
-        Result<void> set_mount_dir(SharedPtr<VFS::Inode> parent) override;
-
         static Result<SharedPtr<VFS::FileSystem>> create();
 
         virtual ~FileSystem() = default;
@@ -343,7 +341,6 @@ namespace TmpFS
         Result<SharedPtr<VFS::Inode>> create_subdirectory(const char* name) override;
 
         Result<void> add_entry(SharedPtr<VFS::Inode> inode, const char* name);
-        Result<void> replace_entry(SharedPtr<VFS::Inode> inode, const char* name);
 
         virtual ~DirInode() = default;
 

kernel/src/main.cpp

@@ -42,10 +42,9 @@ Result<void> init()
     kinfoln("Used memory:     %s", to_dynamic_unit(MemoryManager::used()).release_value().chars());
     kinfoln("Reserved memory: %s", to_dynamic_unit(MemoryManager::reserved()).release_value().chars());
 
-    auto root = TRY(TmpFS::FileSystem::create());
+    VFS::root_fs = TRY(TmpFS::FileSystem::create());
-    TRY(VFS::mount_root(root));
-    TRY(InitRD::populate_vfs());
     TRY(DeviceRegistry::init());
+    InitRD::populate_vfs();
 
     auto init = TRY(VFS::resolve_path("/bin/init", Credentials {}));
     auto init_thread = TRY(Scheduler::new_userspace_thread(init, "/bin/init"));

kernel/src/sys/exec.cpp

@@ -88,11 +88,7 @@ Result<u64> sys_execve(Registers* regs, SyscallArgs args)
     {
         auto& descriptor = current->fd_table[i];
         if (!descriptor.has_value()) continue;
-        if (descriptor->flags & O_CLOEXEC)
+        if (descriptor->flags & O_CLOEXEC) descriptor = {};
-        {
-            descriptor->inode->fs()->remove_handle();
-            descriptor = {};
-        }
     }
 
     MMU::delete_userspace_page_directory(current->directory);
@@ -136,11 +132,7 @@ Result<u64> sys_fork(Registers* regs, SyscallArgs)
     thread->current_directory_path = move(current_directory_path);
     thread->parent = current;
 
-    for (int i = 0; i < FD_MAX; i++)
+    for (int i = 0; i < FD_MAX; i++) { thread->fd_table[i] = current->fd_table[i]; }
-    {
-        thread->fd_table[i] = current->fd_table[i];
-        if (current->fd_table[i].has_value()) current->fd_table[i]->inode->fs()->add_handle();
-    }
 
     image->apply(thread);
 

kernel/src/sys/mount.cpp

@@ -1,34 +0,0 @@
-#include "fs/VFS.h"
-#include "fs/tmpfs/FileSystem.h"
-#include "memory/MemoryManager.h"
-#include "sys/Syscall.h"
-#include "thread/Scheduler.h"
-
-Result<u64> sys_mount(Registers*, SyscallArgs args)
-{
-    auto target = TRY(MemoryManager::strdup_from_user(args[0]));
-    auto fstype = TRY(MemoryManager::strdup_from_user(args[1]));
-
-    auto* current = Scheduler::current();
-    if (current->auth.euid != 0) return err(EPERM);
-
-    // Right now we only support one file system.
-    if (fstype.view() != "tmpfs") return err(ENODEV);
-
-    auto fs = TRY(TmpFS::FileSystem::create());
-    TRY(VFS::mount(target.chars(), fs, current->auth, current->current_directory));
-
-    return 0;
-}
-
-Result<u64> sys_umount(Registers*, SyscallArgs args)
-{
-    auto target = TRY(MemoryManager::strdup_from_user(args[0]));
-
-    auto* current = Scheduler::current();
-    if (current->auth.euid != 0) return err(EPERM);
-
-    TRY(VFS::umount(target.chars(), current->auth, current->current_directory));
-
-    return 0;
-}

kernel/src/sys/open.cpp

@@ -72,8 +72,6 @@ Result<u64> sys_openat(Registers*, SyscallArgs args)
 
     kinfoln("openat: opening file %s from dirfd %d, flags %d, mode %#o = fd %d", path.chars(), dirfd, flags, mode, fd);
 
-    inode->fs()->add_handle();
-
     current->fd_table[fd] = FileDescriptor { inode, 0, flags & FLAGS_TO_KEEP };
 
     return (u64)fd;
@@ -90,8 +88,6 @@ Result<u64> sys_close(Registers*, SyscallArgs args)
 
     if (!descriptor.has_value()) return err(EBADF);
 
-    descriptor->inode->fs()->remove_handle();
-
     descriptor = {};
 
     return 0;

kernel/src/thread/Scheduler.cpp

@@ -182,11 +182,6 @@ namespace Scheduler
         {
             auto stack = thread->kernel_stack;
             MemoryManager::unmap_owned_and_free_vm(stack.bottom(), stack.bytes() / ARCH_PAGE_SIZE).release_value();
-
-            for (int i = 0; i < FD_MAX; i++)
-            {
-                if (thread->fd_table[i].has_value()) thread->fd_table[i]->inode->fs()->remove_handle();
-            }
         }
 
         if (!thread->is_kernel) MMU::delete_userspace_page_directory(thread->directory);

libc/CMakeLists.txt

@@ -24,7 +24,6 @@ set(SOURCES
     src/sys/wait.cpp
     src/sys/ioctl.cpp
     src/sys/utsname.cpp
-    src/sys/mount.cpp
 )
 
 if(${LUNA_ARCH} STREQUAL "x86_64")

libc/include/sys/mount.h

@@ -1,21 +0,0 @@
-/* sys/mount.h: Virtual file system mounting operations. */
-
-#ifndef _SYS_MOUNT_H
-#define _SYS_MOUNT_H
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    /* Mount a file system on target. */
-    int mount(const char* target, const char* fstype);
-
-    /* Unmount the file system mounted on target. */
-    int umount(const char* target);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

libc/src/sys/mount.cpp

@@ -1,19 +0,0 @@
-#include <bits/errno-return.h>
-#include <sys/mount.h>
-#include <sys/syscall.h>
-#include <unistd.h>
-
-extern "C"
-{
-    int mount(const char* target, const char* fstype)
-    {
-        long rc = syscall(SYS_mount, target, fstype);
-        __errno_return(rc, int);
-    }
-
-    int umount(const char* target)
-    {
-        long rc = syscall(SYS_umount, target);
-        __errno_return(rc, int);
-    }
-}

libluna/include/luna/Syscall.h

@@ -4,8 +4,7 @@
     _e(exit) _e(clock_gettime) _e(mmap) _e(munmap) _e(usleep) _e(openat) _e(close) _e(read) _e(getpid) _e(write)       \
         _e(lseek) _e(mkdir) _e(execve) _e(mknod) _e(fork) _e(waitpid) _e(getppid) _e(fcntl) _e(getdents) _e(getuid)    \
             _e(geteuid) _e(getgid) _e(getegid) _e(setuid) _e(setgid) _e(seteuid) _e(setegid) _e(fchmodat) _e(fchownat) \
-                _e(ioctl) _e(fstatat) _e(chdir) _e(getcwd) _e(unlinkat) _e(uname) _e(sethostname) _e(dup2) _e(pipe)    \
+                _e(ioctl) _e(fstatat) _e(chdir) _e(getcwd) _e(unlinkat) _e(uname) _e(sethostname) _e(dup2) _e(pipe)
-                    _e(mount) _e(umount)
 
 enum Syscalls
 {

tools/install.sh

@@ -26,5 +26,3 @@ chmod a+s initrd/bin/su
 
 mkdir -p initrd/home/selene
 chown 1000:1000 initrd/home/selene
-
-mkdir -p initrd/dev