eonix/include/kernel/vfs/file.hpp

#pragma once

#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>

#include <types/buffer.hpp>
#include <types/types.h>

#include <kernel/async/lock.hpp>
#include <kernel/async/waitlist.hpp>
#include <kernel/vfs/dentry.hpp>

namespace fs {

class pipe : public types::non_copyable {
   private:
    static constexpr size_t PIPE_SIZE = 4096;
    static constexpr uint32_t READABLE = 1;
    static constexpr uint32_t WRITABLE = 2;

   private:
    types::buffer buf;
    uint32_t flags;
    kernel::async::mutex mtx;

    kernel::async::wait_list waitlist_r;
    kernel::async::wait_list waitlist_w;

   public:
    pipe();

    void close_read();
    void close_write();

    int write(const char* buf, size_t n);
    int read(char* buf, size_t n);

    constexpr bool is_readable() const { return flags & READABLE; }

    constexpr bool is_writeable() const { return flags & WRITABLE; }
};

struct file {
    mode_t mode; // stores the file type in the same format as inode::mode
    struct file_flags {
        uint32_t read : 1;
        uint32_t write : 1;
        uint32_t append : 1;
    } flags{};

    file(mode_t mode, file_flags flags) : mode(mode), flags(flags) {}

    virtual ~file() = default;

    virtual ssize_t read(char* __user buf, size_t n) = 0;
    virtual ssize_t do_write(const char* __user buf, size_t n) = 0;

    virtual off_t seek(off_t n, int whence) {
        return (void)n, (void)whence, -ESPIPE;
    }

    ssize_t write(const char* __user buf, size_t n) {
        if (!flags.write)
            return -EBADF;

        if (flags.append) {
            seek(0, SEEK_END);
        }

        return do_write(buf, n);
    }

    // regular files should override this method
    virtual int getdents(char* __user buf, size_t cnt) {
        return (void)buf, (void)cnt, -ENOTDIR;
    }
    virtual int getdents64(char* __user buf, size_t cnt) {
        return (void)buf, (void)cnt, -ENOTDIR;
    }
};

struct regular_file : public virtual file {
    virtual ~regular_file() = default;
    std::size_t cursor{};
    inode* ind{};

    regular_file(file_flags flags, size_t cursor, inode* ind);

    virtual ssize_t read(char* __user buf, size_t n) override;
    virtual ssize_t do_write(const char* __user buf, size_t n) override;
    virtual off_t seek(off_t n, int whence) override;
    virtual int getdents(char* __user buf, size_t cnt) override;
    virtual int getdents64(char* __user buf, size_t cnt) override;
};

struct fifo_file : public virtual file {
    virtual ~fifo_file() override;
    std::shared_ptr<pipe> ppipe;

    fifo_file(file_flags flags, std::shared_ptr<fs::pipe> ppipe);

    virtual ssize_t read(char* __user buf, size_t n) override;
    virtual ssize_t do_write(const char* __user buf, size_t n) override;
};

} // namespace fs