tmpfs: rename tmpfs::Inode to tmpfs::FileInode

Now every filesystem must provide fs->create_file_inode() for new inodes :)

kernel/src/fs/VFS.cpp

@@ -3,4 +3,9 @@
 namespace VFS
 {
     SharedPtr<FileSystem> root_fs;
+
+    Inode& root_inode()
+    {
+        return root_fs->root_inode();
+    }
 }

kernel/src/fs/VFS.h

@@ -20,13 +20,33 @@ namespace VFS
 
         virtual ~Inode() = default;
 
-        InodeType type;
+        virtual InodeType type() const = 0;
+
+        virtual usize inode_number() const = 0;
+    };
+
+    class FileInode : Inode
+    {
+      public:
+        Result<Inode*> find(const char*) const override
+        {
+            return err(ENOTDIR);
+        }
+
+        InodeType type() const override
+        {
+            return InodeType::RegularFile;
+        }
+
+        virtual ~FileInode() = default;
     };
 
     class FileSystem
     {
       public:
-        virtual Inode& root() const = 0;
+        virtual Inode& root_inode() const = 0;
+
+        virtual Result<SharedPtr<Inode>> create_file_inode() = 0;
 
         virtual ~FileSystem() = default;
     };
@@ -34,4 +54,6 @@ namespace VFS
     extern SharedPtr<FileSystem> root_fs;
 
     Result<Inode*> resolve_path(const char* path);
+
+    Inode& root_inode();
 }

kernel/src/fs/tmpfs/FileSystem.cpp

@@ -5,29 +5,24 @@ namespace TmpFS
 {
     Result<SharedPtr<VFS::FileSystem>> FileSystem::create()
     {
-        SharedPtr<Inode> root = TRY(make_shared<Inode>());
         SharedPtr<FileSystem> fs = TRY(adopt_shared(new (std::nothrow) FileSystem()));
-        root->set_fs(*fs, {});
-        TRY(fs->set_root(root));
+        SharedPtr<VFS::Inode> root = TRY(fs->create_file_inode());
+        fs->set_root(root);
         return (SharedPtr<VFS::FileSystem>)fs;
     }
 
-    FileSystem::FileSystem()
+    Result<SharedPtr<VFS::Inode>> FileSystem::create_file_inode()
     {
+        SharedPtr<FileInode> inode = TRY(make_shared<FileInode>());
+        inode->set_fs(*this, {});
+        inode->set_inode_number(m_next_inode_number, {});
+        TRY(m_inodes.try_append(inode));
+        m_next_inode_number++;
+        return (SharedPtr<VFS::Inode>)inode;
     }
 
-    Result<void> FileSystem::set_root(SharedPtr<VFS::Inode> root)
+    void FileSystem::set_root(SharedPtr<VFS::Inode> root)
     {
         m_root_inode = root;
-        return m_inodes.try_append(root);
-    }
-
-    Inode::Inode()
-    {
-    }
-
-    void Inode::set_fs(FileSystem& fs, Badge<FileSystem>)
-    {
-        m_fs = &fs;
     }
 }

kernel/src/fs/tmpfs/FileSystem.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "fs/VFS.h"
+#include <luna/Atomic.h>
 #include <luna/Badge.h>
 #include <luna/Vector.h>
 
@@ -8,34 +9,41 @@ namespace TmpFS
     class FileSystem : public VFS::FileSystem
     {
       public:
-        VFS::Inode& root() const override
+        VFS::Inode& root_inode() const override
         {
             return *m_root_inode;
         }
 
+        Result<SharedPtr<VFS::Inode>> create_file_inode() override;
+
         static Result<SharedPtr<VFS::FileSystem>> create();
 
         virtual ~FileSystem() = default;
 
       private:
-        FileSystem();
+        FileSystem() = default;
 
-        Result<void> set_root(SharedPtr<VFS::Inode> root);
+        void set_root(SharedPtr<VFS::Inode> root);
 
         SharedPtr<VFS::Inode> m_root_inode;
         Vector<SharedPtr<VFS::Inode>> m_inodes;
+
+        Atomic<usize> m_next_inode_number { 2 };
     };
 
-    class Inode : public VFS::Inode
+    class FileInode : public VFS::FileInode
     {
       public:
-        Inode();
+        FileInode() = default;
 
-        void set_fs(FileSystem& fs, Badge<FileSystem>);
-
-        Result<VFS::Inode*> find(const char*) const override
+        void set_fs(FileSystem& fs, Badge<FileSystem>)
         {
-            return err(ENOTSUP);
+            m_fs = &fs;
+        }
+
+        void set_inode_number(usize inum, Badge<FileSystem>)
+        {
+            m_inode_number = inum;
         }
 
         VFS::FileSystem& fs() const override
@@ -43,9 +51,15 @@ namespace TmpFS
             return *m_fs;
         }
 
-        virtual ~Inode() = default;
+        usize inode_number() const override
+        {
+            return m_inode_number;
+        }
+
+        virtual ~FileInode() = default;
 
       private:
         VFS::FileSystem* m_fs;
+        usize m_inode_number;
     };
 }

kernel/src/main.cpp

@@ -58,6 +58,9 @@ Result<void> init()
 
     VFS::root_fs = TRY(TmpFS::FileSystem::create());
 
+    VFS::Inode& root_inode = VFS::root_inode();
+    kinfoln("root inode number: %zu", root_inode.inode_number());
+
     TarStream::Entry entry;
     while (TRY(g_initrd.read_next_entry(entry)))
     {