Luna/kernel/src/fs/ext2/Inode.h

#pragma once
#include "fs/ext2/FileSystem.h"

#define EXT2_FIFO 0x1000
#define EXT2_CHR 0x2000
#define EXT2_DIR 0x4000
#define EXT2_BLK 0x6000
#define EXT2_REG 0x8000
#define EXT2_LNK 0xA000
#define EXT2_SOCK 0xC000

namespace Ext2
{
    class Inode : public VFS::Inode
    {
      public:
        VFS::InodeType type() const override
        {
            return m_type;
        }

        usize size() const override;

        mode_t mode() const override
        {
            return m_raw_inode.mode & 07777;
        }

        nlink_t nlinks() const override
        {
            return m_raw_inode.nlinks;
        }

        u32 uid() const override
        {
            return m_raw_inode.uid;
        }

        u32 gid() const override
        {
            return m_raw_inode.gid;
        }

        usize inode_number() const override
        {
            return m_inum;
        }

        VFS::FileSystem* fs() const override
        {
            return m_fs;
        }

        void did_link() override
        {
        }

        void did_unlink() override
        {
        }

        Result<void> chmod(mode_t) override
        {
            return err(EROFS);
        }

        Result<void> chown(u32, u32) override
        {
            return err(EROFS);
        }

        Result<usize> read(u8* buf, usize offset, usize length) const override;

        Result<usize> write(const u8*, usize, usize) override
        {
            return err(EROFS);
        }

        Result<void> truncate(usize) override
        {
            return err(EROFS);
        }

        Result<SharedPtr<VFS::Inode>> find(const char*) const override;

        Option<VFS::DirectoryEntry> get(usize) const override;

        Result<SharedPtr<VFS::Inode>> create_file(const char*) override
        {
            if (m_type != VFS::InodeType::Directory) return err(ENOTDIR);

            return err(EROFS);
        }

        Result<SharedPtr<VFS::Inode>> create_subdirectory(const char*) override
        {
            if (m_type != VFS::InodeType::Directory) return err(ENOTDIR);

            return err(EROFS);
        }

        Result<void> add_entry(SharedPtr<VFS::Inode>, const char*) override
        {
            if (m_type != VFS::InodeType::Directory) return err(ENOTDIR);

            return err(EROFS);
        }

        Result<void> replace_entry(SharedPtr<VFS::Inode>, const char*) override;

        Result<void> remove_entry(const char*) override
        {
            if (m_type != VFS::InodeType::Directory) return err(ENOTDIR);

            return err(EROFS);
        }

        usize entries() const override
        {
            return m_entries.size();
        }

        bool blocking() const override
        {
            return false;
        }

        Result<void> lazy_initialize_dir() const;

        // FIXME: Implement readlink() and device numbers.

        Inode(Badge<FileSystem>, FileSystem* fs);
        virtual ~Inode() = default;

      private:
        VFS::InodeType m_type;
        RawInode m_raw_inode;
        FileSystem* m_fs;
        ino_t m_inum;

        mutable Vector<VFS::DirectoryEntry> m_entries;
        mutable bool m_dir_already_lazily_initialized { false };

        usize find_block(usize index) const;

        friend class FileSystem;
    };
}