WIP file_stat

Author: mhx

CMakeLists.txt

@@ -351,6 +351,7 @@ list(
   src/dwarfs/entry.cpp
   src/dwarfs/error.cpp
   src/dwarfs/file_scanner.cpp
+  src/dwarfs/file_type.cpp
   src/dwarfs/filesystem_extractor.cpp
   src/dwarfs/filesystem_v2.cpp
   src/dwarfs/filesystem_writer.cpp
@@ -366,7 +367,7 @@ list(
   src/dwarfs/nilsimsa.cpp
   src/dwarfs/option_map.cpp
   src/dwarfs/options.cpp
-  src/dwarfs/os_access_posix.cpp
+  src/dwarfs/os_access_generic.cpp
   src/dwarfs/progress.cpp
   src/dwarfs/scanner.cpp
   src/dwarfs/similarity.cpp

include/dwarfs/entry.h

@@ -30,11 +30,10 @@
 #include <string_view>
 #include <vector>
 
-#include <sys/stat.h>
-
 #include <folly/small_vector.h>
 
 #include "dwarfs/entry_interface.h"
+#include "dwarfs/file_stat.h"
 
 namespace dwarfs {
 
@@ -68,16 +67,16 @@ class entry : public entry_interface {
  public:
   enum type_t { E_FILE, E_DIR, E_LINK, E_DEVICE, E_OTHER };
 
-  entry(const std::string& name, std::shared_ptr<entry> parent,
-        const struct ::stat& st);
+  entry(std::string const& name, std::shared_ptr<entry> parent,
+        file_stat const& st);
 
   bool has_parent() const;
   std::shared_ptr<entry> parent() const;
-  void set_name(const std::string& name);
+  void set_name(std::string const& name);
   std::string path() const override;
   std::string dpath() const override;
-  const std::string& name() const override { return name_; }
-  size_t size() const override { return stat_.st_size; }
+  std::string const& name() const override { return name_; }
+  size_t size() const override { return stat_.size; }
   virtual type_t type() const = 0;
   std::string type_string() const override;
   bool is_directory() const override;
@@ -88,11 +87,11 @@ class entry : public entry_interface {
   void update(global_entry_data& data) const;
   virtual void accept(entry_visitor& v, bool preorder = false) = 0;
   virtual void scan(os_access& os, progress& prog) = 0;
-  const struct ::stat& status() const { return stat_; }
+  file_stat const& status() const { return stat_; }
   void set_entry_index(uint32_t index) { entry_index_ = index; }
   std::optional<uint32_t> const& entry_index() const { return entry_index_; }
-  uint64_t raw_inode_num() const { return stat_.st_ino; }
-  uint64_t num_hard_links() const { return stat_.st_nlink; }
+  uint64_t raw_inode_num() const { return stat_.ino; }
+  uint64_t num_hard_links() const { return stat_.nlink; }
   virtual void set_inode_num(uint32_t ino) = 0;
   virtual std::optional<uint32_t> const& inode_num() const = 0;
 
@@ -110,19 +109,19 @@ class entry : public entry_interface {
   uint64_t get_ctime() const override;
   void set_ctime(uint64_t ctime) override;
 
-  void override_size(size_t size) { stat_.st_size = size; }
+  void override_size(size_t size) { stat_.size = size; }
 
  private:
   std::string name_;
   std::weak_ptr<entry> parent_;
-  struct ::stat stat_;
+  file_stat stat_;
   std::optional<uint32_t> entry_index_;
 };
 
 class file : public entry {
  public:
   file(const std::string& name, std::shared_ptr<entry> parent,
-       const struct ::stat& st)
+       file_stat const& st)
       : entry(name, std::move(parent), st) {}
 
   type_t type() const override;

include/dwarfs/file_stat.h

@@ -0,0 +1,101 @@
+/* vim:set ts=2 sw=2 sts=2 et: */
+/**
+ * \author     Marcus Holland-Moritz ([email protected])
+ * \copyright  Copyright (c) Marcus Holland-Moritz
+ *
+ * This file is part of dwarfs.
+ *
+ * dwarfs is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * dwarfs is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with dwarfs.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <filesystem>
+#include <memory>
+#include <type_traits>
+
+#include "dwarfs/file_type.h"
+
+namespace dwarfs {
+
+struct file_stat {
+  using perms_type = std::underlying_type_t<std::filesystem::perms>;
+  using mode_type = uint32_t;
+  using dev_type = uint64_t;
+  using ino_type = uint64_t;
+  using nlink_type = uint64_t;
+  using uid_type = uint32_t;
+  using gid_type = uint32_t;
+  using off_type = int64_t;
+  using blksize_type = int64_t;
+  using blkcnt_type = int64_t;
+  using time_type = int64_t;
+
+  std::filesystem::file_status status() const {
+    return file_mode_to_status(mode);
+  };
+
+  posix_file_type::value type() const {
+    return static_cast<posix_file_type::value>(mode & posix_file_type::mask);
+  };
+
+  perms_type permissions() const { return mode & 07777; };
+
+  void set_permissions(perms_type perms) { mode = type() | (perms & 07777); }
+
+  bool is_directory() const { return type() == posix_file_type::directory; }
+
+  bool is_regular_file() const { return type() == posix_file_type::regular; }
+
+  bool is_symlink() const { return type() == posix_file_type::symlink; }
+
+  bool is_device() const {
+    auto t = type();
+    return t == posix_file_type::block || t == posix_file_type::character;
+  }
+
+  dev_type dev;
+  ino_type ino;
+  nlink_type nlink;
+  mode_type mode;
+  uid_type uid;
+  gid_type gid;
+  dev_type rdev;
+  off_type size;
+  blksize_type blksize;
+  blkcnt_type blocks;
+  time_type atime;
+  time_type mtime;
+  time_type ctime;
+};
+
+template <typename T>
+void copy_file_stat(T* out, file_stat const& in) {
+  out->st_dev = in.dev;
+  out->st_ino = in.ino;
+  out->st_nlink = in.nlink;
+  out->st_mode = in.mode;
+  out->st_uid = in.uid;
+  out->st_gid = in.gid;
+  out->st_rdev = in.rdev;
+  out->st_size = in.size;
+  out->st_blksize = in.blksize;
+  out->st_blocks = in.blocks;
+  out->st_atime = in.atime;
+  out->st_mtime = in.mtime;
+  out->st_ctime = in.ctime;
+}
+
+} // namespace dwarfs

include/dwarfs/file_type.h

@@ -0,0 +1,45 @@
+/* vim:set ts=2 sw=2 sts=2 et: */
+/**
+ * \author     Marcus Holland-Moritz ([email protected])
+ * \copyright  Copyright (c) Marcus Holland-Moritz
+ *
+ * This file is part of dwarfs.
+ *
+ * dwarfs is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * dwarfs is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with dwarfs.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <filesystem>
+
+namespace dwarfs {
+
+struct posix_file_type {
+  enum value : uint16_t {
+    mask = 0170000,
+    socket = 0140000,
+    symlink = 0120000,
+    regular = 0100000,
+    block = 0060000,
+    directory = 0040000,
+    character = 0020000,
+    fifo = 0010000,
+  };
+};
+
+std::filesystem::file_status file_mode_to_status(uint16_t mode);
+uint16_t file_status_to_mode(std::filesystem::file_status status);
+
+} // namespace dwarfs

include/dwarfs/filesystem_v2.h

@@ -32,23 +32,20 @@
 #include <string>
 #include <utility>
 
-#include <sys/types.h>
-
 #include <folly/Expected.h>
 #include <folly/dynamic.h>
 
 #include "dwarfs/fstypes.h"
 #include "dwarfs/metadata_types.h"
 
-struct stat;
-struct statvfs;
-
 namespace dwarfs {
 
 struct cache_tidy_config;
 struct filesystem_options;
 struct rewrite_options;
 struct iovec_read_buf;
+struct file_stat;
+struct vfs_stat;
 
 class filesystem_writer;
 class logger;
@@ -107,7 +104,7 @@ class filesystem_v2 {
     return impl_->find(inode, name);
   }
 
-  int getattr(inode_view entry, struct ::stat* stbuf) const {
+  int getattr(inode_view entry, file_stat* stbuf) const {
     return impl_->getattr(entry, stbuf);
   }
 
@@ -134,7 +131,7 @@ class filesystem_v2 {
     return impl_->readlink(entry);
   }
 
-  int statvfs(struct ::statvfs* stbuf) const { return impl_->statvfs(stbuf); }
+  int statvfs(vfs_stat* stbuf) const { return impl_->statvfs(stbuf); }
 
   int open(inode_view entry) const { return impl_->open(entry); }
 
@@ -176,7 +173,7 @@ class filesystem_v2 {
     virtual std::optional<inode_view> find(int inode) const = 0;
     virtual std::optional<inode_view>
     find(int inode, const char* name) const = 0;
-    virtual int getattr(inode_view entry, struct ::stat* stbuf) const = 0;
+    virtual int getattr(inode_view entry, file_stat* stbuf) const = 0;
     virtual int
     access(inode_view entry, int mode, uid_t uid, gid_t gid) const = 0;
     virtual std::optional<directory_view> opendir(inode_view entry) const = 0;
@@ -186,7 +183,7 @@ class filesystem_v2 {
     virtual int readlink(inode_view entry, std::string* buf) const = 0;
     virtual folly::Expected<std::string, int>
     readlink(inode_view entry) const = 0;
-    virtual int statvfs(struct ::statvfs* stbuf) const = 0;
+    virtual int statvfs(vfs_stat* stbuf) const = 0;
     virtual int open(inode_view entry) const = 0;
     virtual ssize_t
     read(uint32_t inode, char* buf, size_t size, off_t offset) const = 0;

include/dwarfs/metadata_v2.h

@@ -32,23 +32,19 @@
 #include <utility>
 #include <vector>
 
-#include <sys/types.h>
-
 #include <folly/Expected.h>
 #include <folly/dynamic.h>
 
 #include "dwarfs/metadata_types.h"
 
-struct stat;
-struct statvfs;
-
 namespace dwarfs {
 
 class logger;
 
 struct metadata_options;
-
 struct filesystem_info;
+struct file_stat;
+struct vfs_stat;
 
 namespace thrift::metadata {
 class metadata;
@@ -98,7 +94,7 @@ class metadata_v2 {
     return impl_->find(inode, name);
   }
 
-  int getattr(inode_view iv, struct ::stat* stbuf) const {
+  int getattr(inode_view iv, file_stat* stbuf) const {
     return impl_->getattr(iv, stbuf);
   }
 
@@ -127,7 +123,7 @@ class metadata_v2 {
     return impl_->readlink(iv);
   }
 
-  int statvfs(struct ::statvfs* stbuf) const { return impl_->statvfs(stbuf); }
+  int statvfs(vfs_stat* stbuf) const { return impl_->statvfs(stbuf); }
 
   std::optional<chunk_range> get_chunks(int inode) const {
     return impl_->get_chunks(inode);
@@ -163,7 +159,7 @@ class metadata_v2 {
     virtual std::optional<inode_view>
     find(int inode, const char* name) const = 0;
 
-    virtual int getattr(inode_view iv, struct ::stat* stbuf) const = 0;
+    virtual int getattr(inode_view iv, file_stat* stbuf) const = 0;
 
     virtual std::optional<directory_view> opendir(inode_view iv) const = 0;
 
@@ -180,7 +176,7 @@ class metadata_v2 {
 
     virtual folly::Expected<std::string, int> readlink(inode_view iv) const = 0;
 
-    virtual int statvfs(struct ::statvfs* stbuf) const = 0;
+    virtual int statvfs(vfs_stat* stbuf) const = 0;
 
     virtual std::optional<chunk_range> get_chunks(int inode) const = 0;