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

#pragma once
#include "fs/ext2/FileSystem.h"
#include <luna/Buffer.h>
#include <luna/String.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;
        }

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

        void did_link() override
        {
        }

        void did_unlink() override
        {
        }

        Result<u64> query_shared_memory(off_t, usize) override
        {
            return err(ENOTSUP);
        }

        Result<void> set_metadata(const VFS::InodeMetadata&) 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*, mode_t) override
        {
            if (m_type != VFS::InodeType::Directory) return err(ENOTDIR);

            return err(EROFS);
        }

        Result<SharedPtr<VFS::Inode>> create_subdirectory(const char*, mode_t) 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 will_block_if_read() const override
        {
            return false;
        }

        Result<StringView> readlink() override;

        Result<void> lazy_initialize_dir() const;

        // FIXME: Implement 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 Buffer m_singly_indirect_block;

        String m_link;

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

        Result<usize> find_block(usize index) const;

        friend class FileSystem;
    };
}