TheCloud/dwarfs
1
0
Fork 0
mirror of https://github.com/mhx/dwarfs.git synced 2025-09-08 03:49:44 -04:00
Code Issues Packages Projects Releases Wiki Activity

refactor: remove getattr version returning int

Browse Source
This commit is contained in:
Marcus Holland-Moritz 2024-07-28 16:33:10 +02:00
parent aa5f37bb99
commit 6a2cc3f860
13 changed files with 103 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/dwarfs/filesystem_v2.h
View File

@ -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,

6
include/dwarfs/internal/metadata_v2.h
View File

@ -105,8 +105,8 @@ class metadata_v2 {
return impl_->find(inode, name);
}
int getattr(inode_view iv, file_stat* stbuf) const {
return impl_->getattr(iv, stbuf);
file_stat getattr(inode_view iv, std::error_code& ec) const {
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;

6
src/dwarfs/filesystem_extractor.cpp
View File

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

24
src/dwarfs/filesystem_v2.cpp
View File

@ -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>

47
src/dwarfs/internal/metadata_v2.cpp
View File

@ -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()
: file_size(iv, mode);
stbuf->ino = inode + inode_offset_;
stbuf->blksize = options_.block_size;
stbuf->blocks = (stbuf->size + 511) / 512;
stbuf->uid = iv.getuid();
stbuf->gid = iv.getgid();
stbuf->mtime = resolution * (timebase + iv.raw().mtime_offset());
stbuf.size = stbuf.is_directory() ? make_directory_view(iv).entry_count()
: file_size(iv, mode);
stbuf.ino = inode + inode_offset_;
stbuf.blksize = options_.block_size;
stbuf.blocks = (stbuf.size + 511) / 512;
stbuf.uid = iv.getuid();
stbuf.gid = iv.getgid();
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->ctime = resolution * (timebase + iv.raw().ctime_offset());
stbuf.atime = resolution * (timebase + iv.raw().atime_offset());
stbuf.ctime = resolution * (timebase + iv.raw().ctime_offset());
}
stbuf->nlink = options_.enable_nlink && stbuf->is_regular_file()
? DWARFS_NOTHROW(nlinks_.at(inode - file_inode_offset_))
: 1;
stbuf.nlink = options_.enable_nlink && stbuf.is_regular_file()
? DWARFS_NOTHROW(nlinks_.at(inode - file_inode_offset_))
: 1;
if (stbuf->is_device()) {
stbuf->rdev = get_device_id(inode);
if (stbuf.is_device()) {
stbuf.rdev = get_device_id(inode);
}
return 0;
return stbuf;
}
template <typename LoggerPolicy>

26
src/dwarfs_main.cpp
View File

@ -368,10 +368,10 @@ void op_lookup(fuse_req_t req, fuse_ino_t parent, char const* name) {
return ENOENT;
}
file_stat stbuf;
auto err = userdata.fs.getattr(*entry, &stbuf);
std::error_code ec;
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 (err == 0) {
if (!ec) {
::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)) {

10
src/dwarfsbench_main.cpp
View File

@ -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;
if (fs.getattr(inode_data, &stbuf) == 0) {
std::vector<char> buf(stbuf.size);
int fh = fs.open(inode_data);
fs.read(fh, buf.data(), buf.size());
}
auto stbuf = fs.getattr(inode_data);
std::vector<char> buf(stbuf.size);
int fh = fs.open(inode_data);
fs.read(fh, buf.data(), buf.size());
} catch (std::exception const& e) {
iol.err << "error: " << exception_str(e) << "\n";
} catch (...) {

15
src/dwarfsck_main.cpp
View File

@ -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;
fs.getattr(de.inode(), &st);
auto st = fs.getattr(de.inode());
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;
fs.getattr(iv, &st);
auto st = fs.getattr(iv);
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) {
LOG_ERROR << "failed to get attributes for inode " << iv.inode_num();
if (ec) {
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) {

3
test/block_cache_test.cpp
View File

@ -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;
EXPECT_EQ(0, fs.getattr(iv, &stat));
auto stat = fs.getattr(iv);
if (stat.is_regular_file()) {
auto offset = rng() % stat.size;
auto size = rng() % (stat.size - offset);

9
test/compat_test.cpp
View File

@ -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;
ASSERT_EQ(0, fs.getattr(e.inode(), &stbuf));
auto stbuf = fs.getattr(e.inode());
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;
EXPECT_EQ(0, fs.getattr(*v, &st)) << path;
auto st = fs.getattr(*v);
EXPECT_EQ(33333, st.uid) << path;
EXPECT_EQ(44444, st.gid) << path;
}

12
test/dwarfs_benchmark.cpp
View File

@ -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;
fs->getattr(*iv, &st);
auto st = fs->getattr(*iv);
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;
fs->getattr(*iv, &st);
auto st = fs->getattr(*iv);
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;
fs->getattr(*iv, &st);
auto st = fs->getattr(*iv);
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], &buf);
auto r = fs->getattr(ent[i++ % N]);
::benchmark::DoNotOptimize(r);
}
}

56
test/dwarfs_test.cpp
View File

@ -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;
ASSERT_EQ(0, fs.getattr(*entry, &st1));
ASSERT_EQ(0, fs.getattr(*e2, &st2));
auto st1 = fs.getattr(*entry);
auto st2 = fs.getattr(*e2);
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;
ASSERT_EQ(0, fs.getattr(e.inode(), &stbuf));
auto stbuf = fs.getattr(e.inode());
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;
ASSERT_EQ(0, fs.getattr(e.inode(), &stbuf));
auto stbuf = fs.getattr(e.inode());
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;
EXPECT_EQ(0, fs.getattr(*iv16, &st16));
EXPECT_EQ(0, fs.getattr(*iv32, &st32));
auto st16 = fs.getattr(*iv16);
auto st32 = fs.getattr(*iv32);
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;
EXPECT_EQ(0, fs.getattr(*iv00000, &st00000));
EXPECT_EQ(0, fs.getattr(*iv50000, &st50000));
EXPECT_EQ(0, fs.getattr(*iv99999, &st99999));
auto st00000 = fs.getattr(*iv00000);
auto st50000 = fs.getattr(*iv50000);
auto st99999 = fs.getattr(*iv99999);
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;
EXPECT_EQ(fs.getattr(*entry, &st), 0);
auto st = fs.getattr(*entry);
int inode{-1};
@ -1266,10 +1256,8 @@ TEST(file_scanner, file_start_hash) {
EXPECT_TRUE(link1);
EXPECT_TRUE(link2);
file_stat st1, st2;
EXPECT_EQ(0, fs.getattr(*link1, &st1));
EXPECT_EQ(0, fs.getattr(*link2, &st2));
auto st1 = fs.getattr(*link1);
auto st2 = fs.getattr(*link2);
EXPECT_EQ(st1.ino, st2.ino);
EXPECT_EQ(st1.nlink, 2);

41
test/tool_main_test.cpp
View File

@ -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;
fs.getattr(e.inode(), &st);
auto st = fs.getattr(e.inode());
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;
fs.getattr(e.inode(), &st);
auto st = fs.getattr(e.inode());
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;
fs.getattr(e.inode(), &st);
auto st = fs.getattr(e.inode());
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;
if (fs.getattr(e.inode(), &stat) != 0) {
throw std::runtime_error(
fmt::format("getattr() failed for {}", e.path()));
}
auto stat = fs.getattr(e.inode());
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;
EXPECT_EQ(0, fs.getattr(*iv, &stat));
std::error_code ec;
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;
EXPECT_EQ(0, fs.getattr(*iv, &stat));
std::error_code ec;
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;
ASSERT_EQ(0, fs.getattr(*large_link1, &st));
EXPECT_EQ(0, st.size);
ASSERT_EQ(0, fs.getattr(*small_link1, &st));
EXPECT_EQ(0, st.size);
EXPECT_EQ(0, fs.getattr(*large_link1).size);
EXPECT_EQ(0, fs.getattr(*small_link1).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;
ASSERT_EQ(0, fs.getattr(iv, &stat));
auto stat = fs.getattr(iv);
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;
ASSERT_EQ(0, fs.getattr(*iv, &st));
auto st = fs.getattr(*iv);
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;
ASSERT_EQ(0, fs.getattr(*iv, &st)) << i;
auto st = fs.getattr(*iv);
std::string buffer;
buffer.resize(st.size);
auto nread = fs.read(iv->inode_num(), buffer.data(), st.size);