vfs_types.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <cstdint>
 
#include "expected.hpp"
 
namespace vfs {
 
// Forward declarations
struct Inode;
struct Dentry;
struct File;
struct FileSystem;
class MountTable;
 
enum class FileType : uint8_t {
  kUnknown = 0,
  kRegular = 1,
  kDirectory = 2,
  kCharDevice = 3,
  kBlockDevice = 4,
  kSymlink = 5,
  kFifo = 6,
};
 
enum class OpenFlags : uint32_t {
  kOReadOnly = 0x0000,
  kOWriteOnly = 0x0001,
  kOReadWrite = 0x0002,
  kOCreate = 0x0040,
  kOTruncate = 0x0200,
  kOAppend = 0x0400,
  kODirectory = 0x010000,
};
 
[[nodiscard]] inline constexpr auto operator|(OpenFlags lhs, OpenFlags rhs)
    -> OpenFlags {
  return static_cast<OpenFlags>(static_cast<uint32_t>(lhs) |
                                static_cast<uint32_t>(rhs));
}
 
[[nodiscard]] inline constexpr auto operator&(OpenFlags lhs, OpenFlags rhs)
    -> OpenFlags {
  return static_cast<OpenFlags>(static_cast<uint32_t>(lhs) &
                                static_cast<uint32_t>(rhs));
}
 
[[nodiscard]] inline constexpr auto operator~(OpenFlags flags) -> OpenFlags {
  return static_cast<OpenFlags>(~static_cast<uint32_t>(flags));
}
 
inline constexpr auto operator|=(OpenFlags& lhs, OpenFlags rhs) -> OpenFlags& {
  lhs = lhs | rhs;
  return lhs;
}
 
inline constexpr auto operator&=(OpenFlags& lhs, OpenFlags rhs) -> OpenFlags& {
  lhs = lhs & rhs;
  return lhs;
}
 
[[nodiscard]] inline constexpr auto operator==(OpenFlags flags, uint32_t val)
    -> bool {
  return static_cast<uint32_t>(flags) == val;
}
 
[[nodiscard]] inline constexpr auto operator!=(OpenFlags flags, uint32_t val)
    -> bool {
  return static_cast<uint32_t>(flags) != val;
}
 
enum class SeekWhence : int {
  kSet = 0,
  kCur = 1,
  kEnd = 2,
};
 
class InodeOps {
 public:
  virtual auto Lookup(Inode* dir, const char* name) -> Expected<Inode*> = 0;
 
  virtual auto Create(Inode* dir, const char* name, FileType type)
      -> Expected<Inode*> = 0;
 
  virtual auto Unlink(Inode* dir, const char* name) -> Expected<void> = 0;
 
  virtual auto Mkdir(Inode* dir, const char* name) -> Expected<Inode*> = 0;
 
  virtual auto Rmdir(Inode* dir, const char* name) -> Expected<void> = 0;
 
  InodeOps() = default;
  InodeOps(const InodeOps&) = delete;
  InodeOps(InodeOps&&) = delete;
  auto operator=(const InodeOps&) -> InodeOps& = delete;
  auto operator=(InodeOps&&) -> InodeOps& = delete;
  virtual ~InodeOps() = default;
};
struct DirEntry {
  uint64_t ino{0};
  uint8_t type{0};
  char name[256]{};
};
 
class FileOps {
 public:
  virtual auto Read(File* file, void* buf, size_t count)
      -> Expected<size_t> = 0;
 
  virtual auto Write(File* file, const void* buf, size_t count)
      -> Expected<size_t> = 0;
 
  virtual auto Seek(File* file, int64_t offset, SeekWhence whence)
      -> Expected<uint64_t> = 0;
 
  virtual auto Close(File* file) -> Expected<void> = 0;
 
  virtual auto ReadDir(File* file, DirEntry* dirent, size_t count)
      -> Expected<size_t> = 0;
 
  FileOps() = default;
  FileOps(const FileOps&) = delete;
  FileOps(FileOps&&) = delete;
  auto operator=(const FileOps&) -> FileOps& = delete;
  auto operator=(FileOps&&) -> FileOps& = delete;
  virtual ~FileOps() = default;
};
 
}  // namespace vfs