From 890d816f257e932c22068f4043be7a01fcfc7df0 Mon Sep 17 00:00:00 2001
From: Marcus Holland-Moritz <github@mhxnet.de>
Date: Fri, 27 Nov 2020 17:59:35 +0100
Subject: [PATCH] metadata_v2: implement more filesystem functions

---
 include/dwarfs/filesystem_v2.h | 68 ++++++++++++++--------------
 include/dwarfs/metadata_v2.h   |  2 +
 src/dwarfs/block_manager.cpp   |  2 +-
 src/dwarfs/filesystem_v2.cpp   | 81 +++++++++++++++++-----------------
 4 files changed, 80 insertions(+), 73 deletions(-)

diff --git a/include/dwarfs/filesystem_v2.h b/include/dwarfs/filesystem_v2.h
index ed1f812d..a4ed19b3 100644
--- a/include/dwarfs/filesystem_v2.h
+++ b/include/dwarfs/filesystem_v2.h
@@ -62,46 +62,48 @@ class filesystem_v2 {
     impl_->walk(func);
   }
 
-#if 0
-  const dir_entry* find(const char* path) const { return impl_->find(path); }
+  std::optional<entry_view> find(const char* path) const {
+    return impl_->find(path);
+  }
 
-  const dir_entry* find(int inode) const { return impl_->find(inode); }
+  std::optional<entry_view> find(int inode) const { return impl_->find(inode); }
 
-  const dir_entry* find(int inode, const char* name) const {
+  std::optional<entry_view> find(int inode, const char* name) const {
     return impl_->find(inode, name);
   }
 
-  int getattr(const dir_entry* de, struct ::stat* stbuf) const {
-    return impl_->getattr(de, stbuf);
+  int getattr(entry_view entry, struct ::stat* stbuf) const {
+    return impl_->getattr(entry, stbuf);
   }
 
-  int access(const dir_entry* de, int mode, uid_t uid, gid_t gid) const {
-    return impl_->access(de, mode, uid, gid);
+  int access(entry_view entry, int mode, uid_t uid, gid_t gid) const {
+    return impl_->access(entry, mode, uid, gid);
   }
 
-  const directory* opendir(const dir_entry* de) const {
-    return impl_->opendir(de);
+  std::optional<directory_view> opendir(entry_view entry) const {
+    return impl_->opendir(entry);
   }
 
-  const dir_entry*
-  readdir(const directory* d, size_t offset, std::string* name) const {
-    return impl_->readdir(d, offset, name);
+  std::optional<std::pair<entry_view, std::string_view>>
+  readdir(directory_view dir, size_t offset) const {
+    return impl_->readdir(dir, offset);
   }
 
-  size_t dirsize(const directory* d) const { return impl_->dirsize(d); }
+  size_t dirsize(directory_view dir) const { return impl_->dirsize(dir); }
 
-  int readlink(const dir_entry* de, char* buf, size_t size) const {
-    return impl_->readlink(de, buf, size);
+  int readlink(entry_view entry, std::string* buf) const {
+    return impl_->readlink(entry, buf);
   }
 
-  int readlink(const dir_entry* de, std::string* buf) const {
-    return impl_->readlink(de, buf);
+  folly::Expected<std::string_view, int> readlink(entry_view entry) const {
+    return impl_->readlink(entry);
   }
 
   int statvfs(struct ::statvfs* stbuf) const { return impl_->statvfs(stbuf); }
 
-  int open(const dir_entry* de) const { return impl_->open(de); }
+  int open(entry_view entry) const { return impl_->open(entry); }
 
+#if 0
   ssize_t read(uint32_t inode, char* buf, size_t size, off_t offset) const {
     return impl_->read(inode, buf, size, offset);
   }
@@ -118,21 +120,23 @@ class filesystem_v2 {
 
     virtual void dump(std::ostream& os) const = 0;
     virtual void walk(std::function<void(entry_view)> const& func) const = 0;
-#if 0
-    virtual const dir_entry* find(const char* path) const = 0;
-    virtual const dir_entry* find(int inode) const = 0;
-    virtual const dir_entry* find(int inode, const char* name) const = 0;
-    virtual int getattr(const dir_entry* de, struct ::stat* stbuf) const = 0;
+    virtual std::optional<entry_view> find(const char* path) const = 0;
+    virtual std::optional<entry_view> find(int inode) const = 0;
+    virtual std::optional<entry_view>
+    find(int inode, const char* name) const = 0;
+    virtual int getattr(entry_view entry, struct ::stat* stbuf) const = 0;
     virtual int
-    access(const dir_entry* de, int mode, uid_t uid, gid_t gid) const = 0;
-    virtual const directory* opendir(const dir_entry* de) const = 0;
-    virtual const dir_entry*
-    readdir(const directory* d, size_t offset, std::string* name) const = 0;
-    virtual size_t dirsize(const directory* d) const = 0;
-    virtual int readlink(const dir_entry* de, char* buf, size_t size) const = 0;
-    virtual int readlink(const dir_entry* de, std::string* buf) const = 0;
+    access(entry_view entry, int mode, uid_t uid, gid_t gid) const = 0;
+    virtual std::optional<directory_view> opendir(entry_view entry) const = 0;
+    virtual std::optional<std::pair<entry_view, std::string_view>>
+    readdir(directory_view dir, size_t offset) const = 0;
+    virtual size_t dirsize(directory_view dir) const = 0;
+    virtual int readlink(entry_view entry, std::string* buf) const = 0;
+    virtual folly::Expected<std::string_view, int>
+    readlink(entry_view entry) const = 0;
     virtual int statvfs(struct ::statvfs* stbuf) const = 0;
-    virtual int open(const dir_entry* de) const = 0;
+    virtual int open(entry_view entry) const = 0;
+#if 0
     virtual ssize_t
     read(uint32_t inode, char* buf, size_t size, off_t offset) const = 0;
     virtual ssize_t readv(uint32_t inode, iovec_read_buf& buf, size_t size,
diff --git a/include/dwarfs/metadata_v2.h b/include/dwarfs/metadata_v2.h
index 7d535edf..0fba2fd2 100644
--- a/include/dwarfs/metadata_v2.h
+++ b/include/dwarfs/metadata_v2.h
@@ -174,8 +174,10 @@ class metadata_v2 {
 
   static void get_stat_defaults(struct ::stat* defaults);
 
+  // TODO: check if this is needed
   size_t size() const { return impl_->size(); }
 
+  // TODO: check if this is needed
   bool empty() const { return !impl_ || impl_->empty(); }
 
   void walk(std::function<void(entry_view)> const& func) const {
diff --git a/src/dwarfs/block_manager.cpp b/src/dwarfs/block_manager.cpp
index a4a62511..269b49c9 100644
--- a/src/dwarfs/block_manager.cpp
+++ b/src/dwarfs/block_manager.cpp
@@ -179,7 +179,7 @@ void block_manager_<LoggerPolicy>::finish_blocks() {
   }
 
   for (const auto& sti : stats_) {
-    static char const* const percent = "{:.2%}%";
+    static char const* const percent = "{:.2}%";
     const auto& st = sti.second;
     log_.debug() << "blockhash window <" << sti.first << ">: " << st.collisions
                  << " collisions ("
diff --git a/src/dwarfs/filesystem_v2.cpp b/src/dwarfs/filesystem_v2.cpp
index 6c57c6de..9afa7797 100644
--- a/src/dwarfs/filesystem_v2.cpp
+++ b/src/dwarfs/filesystem_v2.cpp
@@ -159,21 +159,21 @@ class filesystem_ : public filesystem_v2::impl {
 
   void dump(std::ostream& os) const override;
   void walk(std::function<void(entry_view)> const& func) const override;
-#if 0
-  const dir_entry* find(const char* path) const override;
-  const dir_entry* find(int inode) const override;
-  const dir_entry* find(int inode, const char* name) const override;
-  int getattr(const dir_entry* de, struct ::stat* stbuf) const override;
-  int access(const dir_entry* de, int mode, uid_t uid,
-             gid_t gid) const override;
-  const directory* opendir(const dir_entry* de) const override;
-  const dir_entry*
-  readdir(const directory* d, size_t offset, std::string* name) const override;
-  size_t dirsize(const directory* d) const override;
-  int readlink(const dir_entry* de, char* buf, size_t size) const override;
-  int readlink(const dir_entry* de, std::string* buf) const override;
+  std::optional<entry_view> find(const char* path) const override;
+  std::optional<entry_view> find(int inode) const override;
+  std::optional<entry_view> find(int inode, const char* name) const override;
+  int getattr(entry_view entry, struct ::stat* stbuf) const override;
+  int access(entry_view entry, int mode, uid_t uid, gid_t gid) const override;
+  std::optional<directory_view> opendir(entry_view entry) const override;
+  std::optional<std::pair<entry_view, std::string_view>>
+  readdir(directory_view dir, size_t offset) const override;
+  size_t dirsize(directory_view dir) const override;
+  int readlink(entry_view entry, std::string* buf) const override;
+  folly::Expected<std::string_view, int>
+  readlink(entry_view entry) const override;
   int statvfs(struct ::statvfs* stbuf) const override;
-  int open(const dir_entry* de) const override;
+  int open(entry_view entry) const override;
+#if 0
   ssize_t
   read(uint32_t inode, char* buf, size_t size, off_t offset) const override;
   ssize_t readv(uint32_t inode, iovec_read_buf& buf, size_t size,
@@ -249,62 +249,62 @@ void filesystem_<LoggerPolicy>::walk(
   meta_.walk(func);
 }
 
-#if 0
 template <typename LoggerPolicy>
-const dir_entry* filesystem_<LoggerPolicy>::find(const char* path) const {
+std::optional<entry_view>
+filesystem_<LoggerPolicy>::find(const char* path) const {
   return meta_.find(path);
 }
 
 template <typename LoggerPolicy>
-const dir_entry* filesystem_<LoggerPolicy>::find(int inode) const {
+std::optional<entry_view> filesystem_<LoggerPolicy>::find(int inode) const {
   return meta_.find(inode);
 }
 
 template <typename LoggerPolicy>
-const dir_entry*
+std::optional<entry_view>
 filesystem_<LoggerPolicy>::find(int inode, const char* name) const {
   return meta_.find(inode, name);
 }
 
 template <typename LoggerPolicy>
-int filesystem_<LoggerPolicy>::getattr(const dir_entry* de,
+int filesystem_<LoggerPolicy>::getattr(entry_view entry,
                                        struct ::stat* stbuf) const {
-  return meta_.getattr(de, stbuf);
+  return meta_.getattr(entry, stbuf);
 }
 
 template <typename LoggerPolicy>
-int filesystem_<LoggerPolicy>::access(const dir_entry* de, int mode, uid_t uid,
+int filesystem_<LoggerPolicy>::access(entry_view entry, int mode, uid_t uid,
                                       gid_t gid) const {
-  return meta_.access(de, mode, uid, gid);
+  return meta_.access(entry, mode, uid, gid);
 }
 
 template <typename LoggerPolicy>
-const directory* filesystem_<LoggerPolicy>::opendir(const dir_entry* de) const {
-  return meta_.opendir(de);
+std::optional<directory_view>
+filesystem_<LoggerPolicy>::opendir(entry_view entry) const {
+  return meta_.opendir(entry);
 }
 
 template <typename LoggerPolicy>
-const dir_entry*
-filesystem_<LoggerPolicy>::readdir(const directory* d, size_t offset,
-                                   std::string* name) const {
-  return meta_.readdir(d, offset, name);
+std::optional<std::pair<entry_view, std::string_view>>
+filesystem_<LoggerPolicy>::readdir(directory_view dir, size_t offset) const {
+  return meta_.readdir(dir, offset);
 }
 
 template <typename LoggerPolicy>
-size_t filesystem_<LoggerPolicy>::dirsize(const directory* d) const {
-  return meta_.dirsize(d);
+size_t filesystem_<LoggerPolicy>::dirsize(directory_view dir) const {
+  return meta_.dirsize(dir);
 }
 
 template <typename LoggerPolicy>
-int filesystem_<LoggerPolicy>::readlink(const dir_entry* de, char* buf,
-                                        size_t size) const {
-  return meta_.readlink(de, buf, size);
-}
-
-template <typename LoggerPolicy>
-int filesystem_<LoggerPolicy>::readlink(const dir_entry* de,
+int filesystem_<LoggerPolicy>::readlink(entry_view entry,
                                         std::string* buf) const {
-  return meta_.readlink(de, buf);
+  return meta_.readlink(entry, buf);
+}
+
+template <typename LoggerPolicy>
+folly::Expected<std::string_view, int>
+filesystem_<LoggerPolicy>::readlink(entry_view entry) const {
+  return meta_.readlink(entry);
 }
 
 template <typename LoggerPolicy>
@@ -314,10 +314,11 @@ int filesystem_<LoggerPolicy>::statvfs(struct ::statvfs* stbuf) const {
 }
 
 template <typename LoggerPolicy>
-int filesystem_<LoggerPolicy>::open(const dir_entry* de) const {
-  return meta_.open(de);
+int filesystem_<LoggerPolicy>::open(entry_view entry) const {
+  return meta_.open(entry);
 }
 
+#if 0
 template <typename LoggerPolicy>
 ssize_t filesystem_<LoggerPolicy>::read(uint32_t inode, char* buf, size_t size,
                                         off_t offset) const {