fatfs.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <ff.h>
 
#include <array>
#include <cstdint>
 
#include "block_device.hpp"
#include "filesystem.hpp"
#include "vfs.hpp"
 
namespace fatfs {
 
class FatFsFileSystem : public vfs::FileSystem {
 public:
  static constexpr uint32_t kRootDirPermissions = 0755U;
  static constexpr uint32_t kDefaultFilePermissions = 0644U;
  static constexpr size_t kPathBufSize = 512;
  static constexpr size_t kMaxInodes = 256;
  static constexpr size_t kMaxOpenFiles = 16;
  static constexpr size_t kMaxOpenDirs = 8;
 
  explicit FatFsFileSystem(uint8_t volume_id);
 
  ~FatFsFileSystem() override;
  FatFsFileSystem(const FatFsFileSystem&) = delete;
  FatFsFileSystem(FatFsFileSystem&&) = delete;
  auto operator=(const FatFsFileSystem&) -> FatFsFileSystem& = delete;
  auto operator=(FatFsFileSystem&&) -> FatFsFileSystem& = delete;
 
  [[nodiscard]] auto GetName() const -> const char* override;
 
  auto Mount(vfs::BlockDevice* device) -> Expected<vfs::Inode*> override;
 
  auto Unmount() -> Expected<void> override;
 
  auto Sync() -> Expected<void> override;
 
  auto AllocateInode() -> Expected<vfs::Inode*> override;
 
  auto FreeInode(vfs::Inode* inode) -> Expected<void> override;
 
  [[nodiscard]] auto GetFileOps() -> vfs::FileOps* override;
 
  auto OpenFil(vfs::Inode* inode, vfs::OpenFlags open_flags) -> Expected<void>;
 
  static auto SetBlockDevice(uint8_t pdrv, vfs::BlockDevice* device) -> void;
 
  [[nodiscard]] static auto GetBlockDevice(uint8_t pdrv) -> vfs::BlockDevice*;
 
  class FatFsInodeOps : public vfs::InodeOps {
   public:
    explicit FatFsInodeOps(FatFsFileSystem* fs) : fs_(fs) {}
 
    auto Lookup(vfs::Inode* dir, const char* name)
        -> Expected<vfs::Inode*> override;
 
    auto Create(vfs::Inode* dir, const char* name, vfs::FileType type)
        -> Expected<vfs::Inode*> override;
 
    auto Unlink(vfs::Inode* dir, const char* name) -> Expected<void> override;
 
    auto Mkdir(vfs::Inode* dir, const char* name)
        -> Expected<vfs::Inode*> override;
 
    auto Rmdir(vfs::Inode* dir, const char* name) -> Expected<void> override;
 
   private:
    FatFsFileSystem* fs_;
  };
 
  class FatFsFileOps : public vfs::FileOps {
   public:
    explicit FatFsFileOps(FatFsFileSystem* fs) : fs_(fs) {}
 
    auto Read(vfs::File* file, void* buf, size_t count)
        -> Expected<size_t> override;
 
    auto Write(vfs::File* file, const void* buf, size_t count)
        -> Expected<size_t> override;
 
    auto Seek(vfs::File* file, int64_t offset, vfs::SeekWhence whence)
        -> Expected<uint64_t> override;
 
    auto Close(vfs::File* file) -> Expected<void> override;
 
    auto ReadDir(vfs::File* file, vfs::DirEntry* dirent, size_t count)
        -> Expected<size_t> override;
 
   private:
    FatFsFileSystem* fs_;
  };
 
  friend class FatFsInodeOps;
  friend class FatFsFileOps;
 
 private:
  uint8_t volume_id_;
  FATFS fatfs_obj_;
  vfs::Inode* root_inode_ = nullptr;
  bool mounted_{false};
 
  struct FatInode {
    vfs::Inode inode;
    std::array<char, kPathBufSize> path{};
    FIL* fil = nullptr;
    bool in_use = false;
    DIR* dir = nullptr;
  };
 
  std::array<FatInode, kMaxInodes> inodes_;
 
  struct FatFileHandle {
    FIL fil;
    bool in_use = false;
  };
 
  std::array<FatFileHandle, kMaxOpenFiles> fil_pool_;
 
  struct FatDirHandle {
    DIR dir;
    bool in_use = false;
  };
 
  std::array<FatDirHandle, kMaxOpenDirs> dir_pool_;
 
  FatFsInodeOps inode_ops_;
  FatFsFileOps file_ops_;
 
  static std::array<vfs::BlockDevice*, FF_VOLUMES> block_devices_;
 
  [[nodiscard]] auto AllocateFatInode() -> FatInode*;
 
  auto FreeFatInode(FatInode* fi) -> void;
 
  [[nodiscard]] auto AllocateFil() -> FIL*;
 
  auto FreeFil(FIL* fil) -> void;
 
  [[nodiscard]] auto AllocateDir() -> DIR*;
 
  auto FreeDir(DIR* dir) -> void;
};
 
}  // namespace fatfs