refactor: remove getattr version returning int

include/dwarfs/filesystem_v2.h

@@ -114,10 +114,6 @@ class filesystem_v2 {
     return impl_->find(inode, name);
   }
 
-  int getattr(inode_view entry, file_stat* stbuf) const {
-    return impl_->getattr(entry, stbuf);
-  }
-
   file_stat getattr(inode_view entry, std::error_code& ec) const {
     return impl_->getattr(entry, ec);
   }
@@ -250,7 +246,6 @@ 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, file_stat* stbuf) const = 0;
     virtual file_stat getattr(inode_view entry, std::error_code& ec) const = 0;
     virtual file_stat getattr(inode_view entry) const = 0;
     virtual int access(inode_view entry, int mode, file_stat::uid_type uid,

include/dwarfs/internal/metadata_v2.h

@@ -105,8 +105,8 @@ class metadata_v2 {
     return impl_->find(inode, name);
   }
 
-  int getattr(inode_view iv, file_stat* stbuf) const {
+  file_stat getattr(inode_view iv, std::error_code& ec) const {
-    return impl_->getattr(iv, stbuf);
+    return impl_->getattr(iv, ec);
   }
 
   std::optional<directory_view> opendir(inode_view iv) const {
@@ -190,7 +190,7 @@ class metadata_v2 {
     virtual std::optional<inode_view>
     find(int inode, const char* name) const = 0;
 
-    virtual int getattr(inode_view iv, file_stat* stbuf) const = 0;
+    virtual file_stat getattr(inode_view iv, std::error_code& ec) const = 0;
 
     virtual std::optional<directory_view> opendir(inode_view iv) const = 0;
 

src/dwarfs/filesystem_extractor.cpp

@@ -347,11 +347,7 @@ bool filesystem_extractor_<LoggerPolicy>::extract(
     auto inode = entry.inode();
 
     auto ae = ::archive_entry_new();
-    file_stat stbuf;
+    auto stbuf = fs.getattr(inode);
-
-    if (fs.getattr(inode, &stbuf) != 0) {
-      DWARFS_THROW(runtime_error, "getattr() failed");
-    }
 
     struct stat st;
 

src/dwarfs/filesystem_v2.cpp

@@ -439,7 +439,6 @@ class filesystem_ final : public filesystem_v2::impl {
   std::optional<inode_view> find(const char* path) const override;
   std::optional<inode_view> find(int inode) const override;
   std::optional<inode_view> find(int inode, const char* name) const override;
-  int getattr(inode_view entry, file_stat* stbuf) const override;
   file_stat getattr(inode_view entry, std::error_code& ec) const override;
   file_stat getattr(inode_view entry) const override;
   int access(inode_view entry, int mode, file_stat::uid_type uid,
@@ -493,7 +492,6 @@ class filesystem_ final : public filesystem_v2::impl {
  private:
   filesystem_info const& get_info() const;
   void check_section(fs_section const& section) const;
-  file_stat getattr_ec(inode_view entry, std::error_code& ec) const;
   std::string
   readlink_ec(inode_view entry, readlink_mode mode, std::error_code& ec) const;
   std::vector<std::future<block_range>>
@@ -517,7 +515,6 @@ class filesystem_ final : public filesystem_v2::impl {
   PERFMON_CLS_TIMER_DECL(find_inode_name)
   PERFMON_CLS_TIMER_DECL(getattr)
   PERFMON_CLS_TIMER_DECL(getattr_ec)
-  PERFMON_CLS_TIMER_DECL(getattr_throw)
   PERFMON_CLS_TIMER_DECL(access)
   PERFMON_CLS_TIMER_DECL(access_ec)
   PERFMON_CLS_TIMER_DECL(opendir)
@@ -600,7 +597,6 @@ filesystem_<LoggerPolicy>::filesystem_(
     PERFMON_CLS_TIMER_INIT(find_inode_name)
     PERFMON_CLS_TIMER_INIT(getattr)
     PERFMON_CLS_TIMER_INIT(getattr_ec)
-    PERFMON_CLS_TIMER_INIT(getattr_throw)
     PERFMON_CLS_TIMER_INIT(access)
     PERFMON_CLS_TIMER_INIT(access_ec)
     PERFMON_CLS_TIMER_INIT(opendir)
@@ -1069,32 +1065,18 @@ filesystem_<LoggerPolicy>::find(int inode, const char* name) const {
   return meta_.find(inode, name);
 }
 
-template <typename LoggerPolicy>
-int filesystem_<LoggerPolicy>::getattr(inode_view entry,
-                                       file_stat* stbuf) const {
-  PERFMON_CLS_SCOPED_SECTION(getattr)
-  return meta_.getattr(entry, stbuf);
-}
-
-template <typename LoggerPolicy>
-file_stat filesystem_<LoggerPolicy>::getattr_ec(inode_view entry,
-                                                std::error_code& ec) const {
-  return call_int_error<file_stat>(
-      [&](auto& stbuf) { return meta_.getattr(entry, &stbuf); }, ec);
-}
-
 template <typename LoggerPolicy>
 file_stat filesystem_<LoggerPolicy>::getattr(inode_view entry,
                                              std::error_code& ec) const {
   PERFMON_CLS_SCOPED_SECTION(getattr_ec)
-  return getattr_ec(entry, ec);
+  return meta_.getattr(entry, ec);
 }
 
 template <typename LoggerPolicy>
 file_stat filesystem_<LoggerPolicy>::getattr(inode_view entry) const {
-  PERFMON_CLS_SCOPED_SECTION(getattr_throw)
+  PERFMON_CLS_SCOPED_SECTION(getattr)
   return call_ec_throw(
-      [&](std::error_code& ec) { return getattr_ec(entry, ec); });
+      [&](std::error_code& ec) { return meta_.getattr(entry, ec); });
 }
 
 template <typename LoggerPolicy>

src/dwarfs/internal/metadata_v2.cpp

@@ -483,7 +483,7 @@ class metadata_ final : public metadata_v2::impl {
   std::optional<inode_view> find(int inode) const override;
   std::optional<inode_view> find(int inode, const char* name) const override;
 
-  int getattr(inode_view iv, file_stat* stbuf) const override;
+  file_stat getattr(inode_view iv, std::error_code& ec) const override;
 
   std::optional<directory_view> opendir(inode_view iv) const override;
 
@@ -1525,10 +1525,13 @@ metadata_<LoggerPolicy>::find(int inode, const char* name) const {
 }
 
 template <typename LoggerPolicy>
-int metadata_<LoggerPolicy>::getattr(inode_view iv, file_stat* stbuf) const {
+file_stat
+metadata_<LoggerPolicy>::getattr(inode_view iv, std::error_code& /*ec*/) const {
   PERFMON_CLS_SCOPED_SECTION(getattr)
 
-  ::memset(stbuf, 0, sizeof(*stbuf));
+  file_stat stbuf;
+
+  ::memset(&stbuf, 0, sizeof(stbuf));
 
   auto mode = iv.mode();
   auto timebase = meta_.timestamp_base();
@@ -1542,35 +1545,35 @@ int metadata_<LoggerPolicy>::getattr(inode_view iv, file_stat* stbuf) const {
     }
   }
 
-  stbuf->mode = mode;
+  stbuf.mode = mode;
 
   if (options_.readonly) {
-    stbuf->mode &= READ_ONLY_MASK;
+    stbuf.mode &= READ_ONLY_MASK;
   }
 
-  stbuf->size = stbuf->is_directory() ? make_directory_view(iv).entry_count()
+  stbuf.size = stbuf.is_directory() ? make_directory_view(iv).entry_count()
-                                      : file_size(iv, mode);
+                                    : file_size(iv, mode);
-  stbuf->ino = inode + inode_offset_;
+  stbuf.ino = inode + inode_offset_;
-  stbuf->blksize = options_.block_size;
+  stbuf.blksize = options_.block_size;
-  stbuf->blocks = (stbuf->size + 511) / 512;
+  stbuf.blocks = (stbuf.size + 511) / 512;
-  stbuf->uid = iv.getuid();
+  stbuf.uid = iv.getuid();
-  stbuf->gid = iv.getgid();
+  stbuf.gid = iv.getgid();
-  stbuf->mtime = resolution * (timebase + iv.raw().mtime_offset());
+  stbuf.mtime = resolution * (timebase + iv.raw().mtime_offset());
   if (mtime_only) {
-    stbuf->atime = stbuf->ctime = stbuf->mtime;
+    stbuf.atime = stbuf.ctime = stbuf.mtime;
   } else {
-    stbuf->atime = resolution * (timebase + iv.raw().atime_offset());
+    stbuf.atime = resolution * (timebase + iv.raw().atime_offset());
-    stbuf->ctime = resolution * (timebase + iv.raw().ctime_offset());
+    stbuf.ctime = resolution * (timebase + iv.raw().ctime_offset());
   }
-  stbuf->nlink = options_.enable_nlink && stbuf->is_regular_file()
+  stbuf.nlink = options_.enable_nlink && stbuf.is_regular_file()
-                     ? DWARFS_NOTHROW(nlinks_.at(inode - file_inode_offset_))
+                    ? DWARFS_NOTHROW(nlinks_.at(inode - file_inode_offset_))
-                     : 1;
+                    : 1;
 
-  if (stbuf->is_device()) {
+  if (stbuf.is_device()) {
-    stbuf->rdev = get_device_id(inode);
+    stbuf.rdev = get_device_id(inode);
   }
 
-  return 0;
+  return stbuf;
 }
 
 template <typename LoggerPolicy>

src/dwarfs_main.cpp

@@ -368,10 +368,10 @@ void op_lookup(fuse_req_t req, fuse_ino_t parent, char const* name) {
       return ENOENT;
     }
 
-    file_stat stbuf;
+    std::error_code ec;
-    auto err = userdata.fs.getattr(*entry, &stbuf);
+    auto stbuf = userdata.fs.getattr(*entry, ec);
 
-    if (err == 0) {
+    if (!ec) {
       struct ::fuse_entry_param e;
 
       ::memset(&e.attr, 0, sizeof(e.attr));
@@ -386,7 +386,7 @@ void op_lookup(fuse_req_t req, fuse_ino_t parent, char const* name) {
       fuse_reply_entry(req, &e);
     }
 
-    return err;
+    return ec.value();
   });
 }
 #endif
@@ -401,16 +401,15 @@ int op_getattr_common(LogProxy& log_, dwarfs_userdata& userdata,
       return ENOENT;
     }
 
-    file_stat stbuf;
+    std::error_code ec;
+    auto stbuf = userdata.fs.getattr(*entry, ec);
 
-    auto err = userdata.fs.getattr(*entry, &stbuf);
+    if (!ec) {
-
-    if (err == 0) {
       ::memset(st, 0, sizeof(*st));
       copy_file_stat(st, stbuf);
     }
 
-    return err;
+    return ec.value();
   });
 }
 
@@ -769,7 +768,6 @@ int op_readdir_common(filesystem_v2& fs, Policy& policy, file_off_t off,
   }
 
   file_off_t lastoff = fs.dirsize(*dir);
-  file_stat stbuf;
   native_stat st;
 
   ::memset(&st, 0, sizeof(st));
@@ -780,7 +778,13 @@ int op_readdir_common(filesystem_v2& fs, Policy& policy, file_off_t off,
 
     auto [entry, name] = *res;
 
-    fs.getattr(entry, &stbuf);
+    std::error_code ec;
+    auto stbuf = fs.getattr(entry, ec);
+
+    if (ec) {
+      return ec.value();
+    }
+
     copy_file_stat(&st, stbuf);
 
     if (!policy.add_entry(name, st, off)) {

src/dwarfsbench_main.cpp

@@ -109,12 +109,10 @@ int dwarfsbench_main(int argc, sys_char** argv, iolayer const& iol) {
       if (inode_data.is_regular_file()) {
         pool.add_job([&fs, &iol, inode_data] {
           try {
-            file_stat stbuf;
+            auto stbuf = fs.getattr(inode_data);
-            if (fs.getattr(inode_data, &stbuf) == 0) {
+            std::vector<char> buf(stbuf.size);
-              std::vector<char> buf(stbuf.size);
+            int fh = fs.open(inode_data);
-              int fh = fs.open(inode_data);
+            fs.read(fh, buf.data(), buf.size());
-              fs.read(fh, buf.data(), buf.size());
-            }
           } catch (std::exception const& e) {
             iol.err << "error: " << exception_str(e) << "\n";
           } catch (...) {

src/dwarfsck_main.cpp

@@ -69,8 +69,7 @@ void do_list_files(filesystem_v2& fs, iolayer const& iol, bool verbose) {
 
   file_stat::off_type max_inode_size{0};
   fs.walk([&](auto const& de) {
-    file_stat st;
+    auto st = fs.getattr(de.inode());
-    fs.getattr(de.inode(), &st);
     max_inode_size = std::max(max_inode_size, st.size);
   });
 
@@ -78,8 +77,7 @@ void do_list_files(filesystem_v2& fs, iolayer const& iol, bool verbose) {
 
   fs.walk([&](auto const& de) {
     auto iv = de.inode();
-    file_stat st;
+    auto st = fs.getattr(iv);
-    fs.getattr(iv, &st);
     auto name = de.unix_path();
     utf8_sanitize(name);
 
@@ -111,14 +109,15 @@ void do_checksum(logger& lgr, filesystem_v2& fs, iolayer const& iol,
     auto iv = de.inode();
 
     if (iv.is_regular_file()) {
-      file_stat st;
+      std::error_code ec;
+      auto st = fs.getattr(iv, ec);
 
-      if (fs.getattr(de.inode(), &st) != 0) {
+      if (ec) {
-        LOG_ERROR << "failed to get attributes for inode " << iv.inode_num();
+        LOG_ERROR << "failed to get attributes for inode " << iv.inode_num()
+                  << ": " << ec.message();
         return;
       }
 
-      std::error_code ec;
       auto ranges = fs.readv(iv.inode_num(), st.size, ec);
 
       if (ec) {

test/block_cache_test.cpp

@@ -227,8 +227,7 @@ TEST_P(options_test, cache_stress) {
   for (auto& reqs : data) {
     while (reqs.size() < num_read_reqs) {
       auto iv = inodes[inode_dist(rng)];
-      file_stat stat;
+      auto stat = fs.getattr(iv);
-      EXPECT_EQ(0, fs.getattr(iv, &stat));
       if (stat.is_regular_file()) {
         auto offset = rng() % stat.size;
         auto size = rng() % (stat.size - offset);

test/compat_test.cpp

@@ -836,10 +836,9 @@ void check_compat(logger& lgr, filesystem_v2 const& fs,
   EXPECT_GT(dumpss.str().size(), 1000) << dumpss.str();
 
   auto entry = fs.find("/format.sh");
-  file_stat st;
 
   ASSERT_TRUE(entry);
-  EXPECT_EQ(0, fs.getattr(*entry, &st));
+  auto st = fs.getattr(*entry);
   EXPECT_EQ(94, st.size);
   EXPECT_EQ(S_IFREG | 0755, st.mode);
   EXPECT_EQ(1000, st.uid);
@@ -953,8 +952,7 @@ void check_compat(logger& lgr, filesystem_v2 const& fs,
     std::vector<int> inodes;
 
     (fs.*mp)([&](dir_entry_view e) {
-      file_stat stbuf;
+      auto stbuf = fs.getattr(e.inode());
-      ASSERT_EQ(0, fs.getattr(e.inode(), &stbuf));
       inodes.push_back(stbuf.ino);
       EXPECT_TRUE(entries.emplace(e.unix_path(), stbuf).second);
     });
@@ -1268,8 +1266,7 @@ TEST_P(set_uidgid_test, read_legacy_image) {
     EXPECT_EQ(33333, v->getuid()) << path;
     EXPECT_EQ(44444, v->getgid()) << path;
 
-    file_stat st;
+    auto st = fs.getattr(*v);
-    EXPECT_EQ(0, fs.getattr(*v, &st)) << path;
     EXPECT_EQ(33333, st.uid) << path;
     EXPECT_EQ(44444, st.gid) << path;
   }

test/dwarfs_benchmark.cpp

@@ -224,8 +224,7 @@ class filesystem : public ::benchmark::Fixture {
 
   void read_bench(::benchmark::State& state, const char* file) {
     auto iv = fs->find(file);
-    file_stat st;
+    auto st = fs->getattr(*iv);
-    fs->getattr(*iv, &st);
     auto i = fs->open(*iv);
     std::string buf;
     buf.resize(st.size);
@@ -238,8 +237,7 @@ class filesystem : public ::benchmark::Fixture {
 
   void readv_bench(::benchmark::State& state, char const* file) {
     auto iv = fs->find(file);
-    file_stat st;
+    auto st = fs->getattr(*iv);
-    fs->getattr(*iv, &st);
     auto i = fs->open(*iv);
 
     for (auto _ : state) {
@@ -251,8 +249,7 @@ class filesystem : public ::benchmark::Fixture {
 
   void readv_future_bench(::benchmark::State& state, char const* file) {
     auto iv = fs->find(file);
-    file_stat st;
+    auto st = fs->getattr(*iv);
-    fs->getattr(*iv, &st);
     auto i = fs->open(*iv);
 
     for (auto _ : state) {
@@ -275,8 +272,7 @@ class filesystem : public ::benchmark::Fixture {
     }
 
     for (auto _ : state) {
-      file_stat buf;
+      auto r = fs->getattr(ent[i++ % N]);
-      auto r = fs->getattr(ent[i++ % N], &buf);
       ::benchmark::DoNotOptimize(r);
     }
   }

test/dwarfs_test.cpp

@@ -246,10 +246,9 @@ void basic_end_to_end_test(std::string const& compressor,
   EXPECT_GT(dumpss.str().size(), 1000) << dumpss.str();
 
   auto entry = fs.find("/foo.pl");
-  file_stat st;
 
   ASSERT_TRUE(entry);
-  EXPECT_EQ(fs.getattr(*entry, &st), 0);
+  auto st = fs.getattr(*entry);
   EXPECT_EQ(st.size, 23456);
   EXPECT_EQ(st.uid, set_uid ? 0 : 1337);
   EXPECT_EQ(st.gid, 0);
@@ -268,7 +267,7 @@ void basic_end_to_end_test(std::string const& compressor,
   entry = fs.find("/somelink");
 
   ASSERT_TRUE(entry);
-  EXPECT_EQ(fs.getattr(*entry, &st), 0);
+  st = fs.getattr(*entry);
   EXPECT_EQ(st.size, 16);
   EXPECT_EQ(st.uid, set_uid ? 0 : 1000);
   EXPECT_EQ(st.gid, set_gid ? 0 : 100);
@@ -286,7 +285,7 @@ void basic_end_to_end_test(std::string const& compressor,
   entry = fs.find("/somedir/bad");
 
   ASSERT_TRUE(entry);
-  EXPECT_EQ(fs.getattr(*entry, &st), 0);
+  st = fs.getattr(*entry);
   EXPECT_EQ(st.size, 6);
 
   EXPECT_EQ(fs.readlink(*entry, &link), 0);
@@ -296,7 +295,7 @@ void basic_end_to_end_test(std::string const& compressor,
 
   if (with_specials) {
     ASSERT_TRUE(entry);
-    EXPECT_EQ(fs.getattr(*entry, &st), 0);
+    st = fs.getattr(*entry);
     EXPECT_EQ(st.size, 0);
     EXPECT_EQ(st.uid, set_uid ? 0 : 1000);
     EXPECT_EQ(st.gid, set_gid ? 0 : 100);
@@ -313,7 +312,7 @@ void basic_end_to_end_test(std::string const& compressor,
 
   if (with_devices) {
     ASSERT_TRUE(entry);
-    EXPECT_EQ(fs.getattr(*entry, &st), 0);
+    st = fs.getattr(*entry);
     EXPECT_EQ(st.size, 0);
     EXPECT_EQ(st.uid, 0);
     EXPECT_EQ(st.gid, 0);
@@ -327,7 +326,7 @@ void basic_end_to_end_test(std::string const& compressor,
 
   if (with_devices) {
     ASSERT_TRUE(entry);
-    EXPECT_EQ(fs.getattr(*entry, &st), 0);
+    st = fs.getattr(*entry);
     EXPECT_EQ(st.size, 0);
     EXPECT_EQ(st.uid, 0);
     EXPECT_EQ(st.gid, 0);
@@ -394,9 +393,8 @@ void basic_end_to_end_test(std::string const& compressor,
 
   EXPECT_EQ(entry->inode_num(), e2->inode_num());
 
-  file_stat st1, st2;
+  auto st1 = fs.getattr(*entry);
-  ASSERT_EQ(0, fs.getattr(*entry, &st1));
+  auto st2 = fs.getattr(*e2);
-  ASSERT_EQ(0, fs.getattr(*e2, &st2));
 
   EXPECT_EQ(st1.ino, st2.ino);
   if (enable_nlink) {
@@ -413,14 +411,14 @@ void basic_end_to_end_test(std::string const& compressor,
   entry = fs.find(0, "baz.pl");
   ASSERT_TRUE(entry);
   EXPECT_GT(entry->inode_num(), 0);
-  ASSERT_EQ(0, fs.getattr(*entry, &st1));
+  st1 = fs.getattr(*entry);
   EXPECT_EQ(23456, st1.size);
   e2 = fs.find(0, "somedir");
   ASSERT_TRUE(e2);
-  ASSERT_EQ(0, fs.getattr(*e2, &st2));
+  st2 = fs.getattr(*e2);
   entry = fs.find(st2.ino, "ipsum.py");
   ASSERT_TRUE(entry);
-  ASSERT_EQ(0, fs.getattr(*entry, &st1));
+  st1 = fs.getattr(*entry);
   EXPECT_EQ(access_fail ? 0 : 10000, st1.size);
   EXPECT_EQ(0, fs.access(*entry, R_OK, 1000, 100));
   entry = fs.find(0, "baz.pl");
@@ -432,8 +430,7 @@ void basic_end_to_end_test(std::string const& compressor,
     std::vector<int> inodes;
 
     (fs.*mp)([&](dir_entry_view e) {
-      file_stat stbuf;
+      auto stbuf = fs.getattr(e.inode());
-      ASSERT_EQ(0, fs.getattr(e.inode(), &stbuf));
       inodes.push_back(stbuf.ino);
       auto path = e.path();
       if (!path.empty()) {
@@ -647,8 +644,7 @@ TEST_P(packing_test, regression_empty_fs) {
 
   fs.walk([&](dir_entry_view e) {
     ++num;
-    file_stat stbuf;
+    auto stbuf = fs.getattr(e.inode());
-    ASSERT_EQ(0, fs.getattr(e.inode(), &stbuf));
     EXPECT_TRUE(stbuf.is_directory());
   });
 
@@ -792,10 +788,9 @@ TEST_P(compression_regression, github45) {
 
   auto check_file = [&](char const* name, std::string const& contents) {
     auto entry = fs.find(name);
-    file_stat st;
 
     ASSERT_TRUE(entry);
-    EXPECT_EQ(fs.getattr(*entry, &st), 0);
+    auto st = fs.getattr(*entry);
     EXPECT_EQ(st.size, file_size);
 
     int inode = fs.open(*entry);
@@ -1087,10 +1082,8 @@ TEST(filesystem, uid_gid_32bit) {
   EXPECT_TRUE(iv16);
   EXPECT_TRUE(iv32);
 
-  file_stat st16, st32;
+  auto st16 = fs.getattr(*iv16);
-
+  auto st32 = fs.getattr(*iv32);
-  EXPECT_EQ(0, fs.getattr(*iv16, &st16));
-  EXPECT_EQ(0, fs.getattr(*iv32, &st32));
 
   EXPECT_EQ(60000, st16.uid);
   EXPECT_EQ(65535, st16.gid);
@@ -1125,11 +1118,9 @@ TEST(filesystem, uid_gid_count) {
   EXPECT_TRUE(iv50000);
   EXPECT_TRUE(iv99999);
 
-  file_stat st00000, st50000, st99999;
+  auto st00000 = fs.getattr(*iv00000);
-
+  auto st50000 = fs.getattr(*iv50000);
-  EXPECT_EQ(0, fs.getattr(*iv00000, &st00000));
+  auto st99999 = fs.getattr(*iv99999);
-  EXPECT_EQ(0, fs.getattr(*iv50000, &st50000));
-  EXPECT_EQ(0, fs.getattr(*iv99999, &st99999));
 
   EXPECT_EQ(50000, st00000.uid);
   EXPECT_EQ(250000, st00000.gid);
@@ -1203,8 +1194,7 @@ TEST(section_index_regression, github183) {
 
   ASSERT_TRUE(entry);
 
-  file_stat st;
+  auto st = fs.getattr(*entry);
-  EXPECT_EQ(fs.getattr(*entry, &st), 0);
 
   int inode{-1};
 
@@ -1266,10 +1256,8 @@ TEST(file_scanner, file_start_hash) {
   EXPECT_TRUE(link1);
   EXPECT_TRUE(link2);
 
-  file_stat st1, st2;
+  auto st1 = fs.getattr(*link1);
-
+  auto st2 = fs.getattr(*link2);
-  EXPECT_EQ(0, fs.getattr(*link1, &st1));
-  EXPECT_EQ(0, fs.getattr(*link2, &st2));
 
   EXPECT_EQ(st1.ino, st2.ino);
   EXPECT_EQ(st1.nlink, 2);

test/tool_main_test.cpp

@@ -374,8 +374,7 @@ build_with_args(std::vector<std::string> opt_args = {}) {
 std::set<uint64_t> get_all_fs_times(filesystem_v2 const& fs) {
   std::set<uint64_t> times;
   fs.walk([&](auto const& e) {
-    file_stat st;
+    auto st = fs.getattr(e.inode());
-    fs.getattr(e.inode(), &st);
     times.insert(st.atime);
     times.insert(st.ctime);
     times.insert(st.mtime);
@@ -386,8 +385,7 @@ std::set<uint64_t> get_all_fs_times(filesystem_v2 const& fs) {
 std::set<uint64_t> get_all_fs_uids(filesystem_v2 const& fs) {
   std::set<uint64_t> uids;
   fs.walk([&](auto const& e) {
-    file_stat st;
+    auto st = fs.getattr(e.inode());
-    fs.getattr(e.inode(), &st);
     uids.insert(st.uid);
   });
   return uids;
@@ -396,8 +394,7 @@ std::set<uint64_t> get_all_fs_uids(filesystem_v2 const& fs) {
 std::set<uint64_t> get_all_fs_gids(filesystem_v2 const& fs) {
   std::set<uint64_t> gids;
   fs.walk([&](auto const& e) {
-    file_stat st;
+    auto st = fs.getattr(e.inode());
-    fs.getattr(e.inode(), &st);
     gids.insert(st.gid);
   });
   return gids;
@@ -878,11 +875,7 @@ TEST(mkdwarfs_test, metadata_path) {
 
   std::map<size_t, dir_entry_view> entries;
   fs.walk([&](auto e) {
-    file_stat stat;
+    auto stat = fs.getattr(e.inode());
-    if (fs.getattr(e.inode(), &stat) != 0) {
-      throw std::runtime_error(
-          fmt::format("getattr() failed for {}", e.path()));
-    }
     if (stat.is_regular_file()) {
       entries.emplace(stat.size, e);
     }
@@ -1010,8 +1003,9 @@ TEST(mkdwarfs_test, metadata_specials) {
   auto iv = fs.find("/block");
   ASSERT_TRUE(iv);
 
-  file_stat stat;
+  std::error_code ec;
-  EXPECT_EQ(0, fs.getattr(*iv, &stat));
+  auto stat = fs.getattr(*iv, ec);
+  EXPECT_FALSE(ec);
 
   EXPECT_TRUE(stat.is_device());
   EXPECT_EQ(77, stat.rdev);
@@ -1035,8 +1029,9 @@ TEST(mkdwarfs_test, metadata_time_resolution) {
   auto iv = fs.find("/suid");
   ASSERT_TRUE(iv);
 
-  file_stat stat;
+  std::error_code ec;
-  EXPECT_EQ(0, fs.getattr(*iv, &stat));
+  auto stat = fs.getattr(*iv, ec);
+  EXPECT_FALSE(ec);
   EXPECT_EQ(3300, stat.atime);
   EXPECT_EQ(2220, stat.mtime);
   EXPECT_EQ(1080, stat.ctime);
@@ -2549,11 +2544,8 @@ TEST_P(map_file_error_test, delayed) {
     ASSERT_TRUE(small_link2);
     EXPECT_EQ(large_link1->inode_num(), large_link2->inode_num());
     EXPECT_EQ(small_link1->inode_num(), small_link2->inode_num());
-    file_stat st;
+    EXPECT_EQ(0, fs.getattr(*large_link1).size);
-    ASSERT_EQ(0, fs.getattr(*large_link1, &st));
+    EXPECT_EQ(0, fs.getattr(*small_link1).size);
-    EXPECT_EQ(0, st.size);
-    ASSERT_EQ(0, fs.getattr(*small_link1, &st));
-    EXPECT_EQ(0, st.size);
   }
 
   std::unordered_map<fs::path, std::string, fs_path_hash> actual_files;
@@ -2561,8 +2553,7 @@ TEST_P(map_file_error_test, delayed) {
     auto iv = dev.inode();
     if (iv.is_regular_file()) {
       std::string data;
-      file_stat stat;
+      auto stat = fs.getattr(iv);
-      ASSERT_EQ(0, fs.getattr(iv, &stat));
       data.resize(stat.size);
       ASSERT_EQ(data.size(), fs.read(iv.inode_num(), data.data(), data.size()));
       ASSERT_TRUE(actual_files.emplace(dev.fs_path(), std::move(data)).second);
@@ -2694,8 +2685,7 @@ TEST(block_cache, sequential_access_detector) {
         auto iv = fs.find(pstr.c_str());
         ASSERT_TRUE(iv);
         ASSERT_TRUE(iv->is_regular_file());
-        file_stat st;
+        auto st = fs.getattr(*iv);
-        ASSERT_EQ(0, fs.getattr(*iv, &st));
         ASSERT_EQ(data.size(), st.size);
         std::string buffer;
         buffer.resize(data.size());
@@ -2799,8 +2789,7 @@ TEST(file_scanner, large_file_handling) {
   for (size_t i = 0; i < data.size(); ++i) {
     auto iv = fs.find(fmt::format("f{}", i).c_str());
     ASSERT_TRUE(iv) << i;
-    file_stat st;
+    auto st = fs.getattr(*iv);
-    ASSERT_EQ(0, fs.getattr(*iv, &st)) << i;
     std::string buffer;
     buffer.resize(st.size);
     auto nread = fs.read(iv->inode_num(), buffer.data(), st.size);