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

Consistent naming

Browse Source
This commit is contained in:
Marcus Holland-Moritz 2021-03-18 00:09:49 +01:00
parent bfe8e2e4c4
commit 59d249c1fb
2 changed files with 86 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
include/dwarfs/metadata_v2.h
View File

@ -96,12 +96,12 @@ class metadata_v2 {
return impl_->find(inode, name); return impl_->find(inode, name);
} }
int getattr(inode_view entry, struct ::stat* stbuf) const { int getattr(inode_view iv, struct ::stat* stbuf) const {
return impl_->getattr(entry, stbuf); return impl_->getattr(iv, stbuf);
} }
std::optional<directory_view> opendir(inode_view entry) const { std::optional<directory_view> opendir(inode_view iv) const {
return impl_->opendir(entry); return impl_->opendir(iv);
} }
std::optional<std::pair<inode_view, std::string_view>> std::optional<std::pair<inode_view, std::string_view>>
@ -111,18 +111,18 @@ class metadata_v2 {
size_t dirsize(directory_view dir) const { return impl_->dirsize(dir); } size_t dirsize(directory_view dir) const { return impl_->dirsize(dir); }
int access(inode_view entry, int mode, uid_t uid, gid_t gid) const { int access(inode_view iv, int mode, uid_t uid, gid_t gid) const {
return impl_->access(entry, mode, uid, gid); return impl_->access(iv, mode, uid, gid);
} }
int open(inode_view entry) const { return impl_->open(entry); } int open(inode_view iv) const { return impl_->open(iv); }
int readlink(inode_view entry, std::string* buf) const { int readlink(inode_view iv, std::string* buf) const {
return impl_->readlink(entry, buf); return impl_->readlink(iv, buf);
} }
folly::Expected<std::string_view, int> readlink(inode_view entry) const { folly::Expected<std::string_view, int> readlink(inode_view iv) const {
return impl_->readlink(entry); return impl_->readlink(iv);
} }
int statvfs(struct ::statvfs* stbuf) const { return impl_->statvfs(stbuf); } int statvfs(struct ::statvfs* stbuf) const { return impl_->statvfs(stbuf); }
@ -161,24 +161,23 @@ class metadata_v2 {
virtual std::optional<inode_view> virtual std::optional<inode_view>
find(int inode, const char* name) const = 0; find(int inode, const char* name) const = 0;
virtual int getattr(inode_view entry, struct ::stat* stbuf) const = 0; virtual int getattr(inode_view iv, struct ::stat* stbuf) const = 0;
virtual std::optional<directory_view> opendir(inode_view entry) const = 0; virtual std::optional<directory_view> opendir(inode_view iv) const = 0;
virtual std::optional<std::pair<inode_view, std::string_view>> virtual std::optional<std::pair<inode_view, std::string_view>>
readdir(directory_view dir, size_t offset) const = 0; readdir(directory_view dir, size_t offset) const = 0;
virtual size_t dirsize(directory_view dir) const = 0; virtual size_t dirsize(directory_view dir) const = 0;
virtual int virtual int access(inode_view iv, int mode, uid_t uid, gid_t gid) const = 0;
access(inode_view entry, int mode, uid_t uid, gid_t gid) const = 0;
virtual int open(inode_view entry) const = 0; virtual int open(inode_view iv) const = 0;
virtual int readlink(inode_view entry, std::string* buf) const = 0; virtual int readlink(inode_view iv, std::string* buf) const = 0;
virtual folly::Expected<std::string_view, int> virtual folly::Expected<std::string_view, int>
readlink(inode_view entry) const = 0; readlink(inode_view iv) const = 0;
virtual int statvfs(struct ::statvfs* stbuf) const = 0; virtual int statvfs(struct ::statvfs* stbuf) const = 0;

140
src/dwarfs/metadata_v2.cpp
View File

@ -201,9 +201,9 @@ class metadata_ final : public metadata_v2::impl {
std::optional<inode_view> find(int inode) const override; std::optional<inode_view> find(int inode) const override;
std::optional<inode_view> find(int inode, const char* name) const override; std::optional<inode_view> find(int inode, const char* name) const override;
int getattr(inode_view entry, struct ::stat* stbuf) const override; int getattr(inode_view iv, struct ::stat* stbuf) const override;
std::optional<directory_view> opendir(inode_view entry) const override; std::optional<directory_view> opendir(inode_view iv) const override;
std::optional<std::pair<inode_view, std::string_view>> std::optional<std::pair<inode_view, std::string_view>>
readdir(directory_view dir, size_t offset) const override; readdir(directory_view dir, size_t offset) const override;
@ -212,14 +212,13 @@ class metadata_ final : public metadata_v2::impl {
return 2 + dir.entry_count(); // adds '.' and '..', which we fake in ;-) return 2 + dir.entry_count(); // adds '.' and '..', which we fake in ;-)
} }
int access(inode_view entry, int mode, uid_t uid, gid_t gid) const override; int access(inode_view iv, int mode, uid_t uid, gid_t gid) const override;
int open(inode_view entry) const override; int open(inode_view iv) const override;
int readlink(inode_view entry, std::string* buf) const override; int readlink(inode_view iv, std::string* buf) const override;
folly::Expected<std::string_view, int> folly::Expected<std::string_view, int> readlink(inode_view iv) const override;
readlink(inode_view entry) const override;
int statvfs(struct ::statvfs* stbuf) const override; int statvfs(struct ::statvfs* stbuf) const override;
@ -312,17 +311,17 @@ class metadata_ final : public metadata_v2::impl {
auto it = std::lower_bound(range.begin(), range.end(), rank, auto it = std::lower_bound(range.begin(), range.end(), rank,
[&](auto inode, inode_rank r) { [&](auto inode, inode_rank r) {
auto e = make_inode_view(inode); auto iv = make_inode_view(inode);
return get_inode_rank(e.mode()) < r; return get_inode_rank(iv.mode()) < r;
}); });
return *it; return *it;
} }
} }
directory_view make_directory_view(inode_view inode) const { directory_view make_directory_view(inode_view iv) const {
// TODO: revisit: is this the way to do it? // TODO: revisit: is this the way to do it?
return directory_view(inode.inode_num(), &meta_); return directory_view(iv.inode_num(), &meta_);
} }
// TODO: see if we really need to pass the extra dir_entry_view in // TODO: see if we really need to pass the extra dir_entry_view in
@ -369,19 +368,19 @@ class metadata_ final : public metadata_v2::impl {
return rv; return rv;
} }
size_t reg_file_size(inode_view entry) const { size_t reg_file_size(inode_view iv) const {
auto cr = get_chunk_range(entry.inode_num()); auto cr = get_chunk_range(iv.inode_num());
DWARFS_CHECK(cr, "invalid chunk range"); DWARFS_CHECK(cr, "invalid chunk range");
return std::accumulate( return std::accumulate(
cr->begin(), cr->end(), static_cast<size_t>(0), cr->begin(), cr->end(), static_cast<size_t>(0),
[](size_t s, chunk_view cv) { return s + cv.size(); }); [](size_t s, chunk_view cv) { return s + cv.size(); });
} }
size_t file_size(inode_view entry, uint16_t mode) const { size_t file_size(inode_view iv, uint16_t mode) const {
if (S_ISREG(mode)) { if (S_ISREG(mode)) {
return reg_file_size(entry); return reg_file_size(iv);
} else if (S_ISLNK(mode)) { } else if (S_ISLNK(mode)) {
return link_value(entry).size(); return link_value(iv).size();
} else { } else {
return 0; return 0;
} }
@ -414,8 +413,8 @@ class metadata_ final : public metadata_v2::impl {
return rv; return rv;
} }
std::string_view link_value(inode_view entry) const { std::string_view link_value(inode_view iv) const {
return meta_.symlinks()[meta_.symlink_table()[entry.inode_num() - return meta_.symlinks()[meta_.symlink_table()[iv.inode_num() -
symlink_inode_offset_]]; symlink_inode_offset_]];
} }
@ -506,9 +505,9 @@ void metadata_<LoggerPolicy>::dump(
std::ostream& os, const std::string& indent, dir_entry_view entry, std::ostream& os, const std::string& indent, dir_entry_view entry,
int detail_level, int detail_level,
std::function<void(const std::string&, uint32_t)> const& icb) const { std::function<void(const std::string&, uint32_t)> const& icb) const {
auto inode_data = entry.inode(); auto iv = entry.inode();
auto mode = inode_data.mode(); auto mode = iv.mode();
auto inode = inode_data.inode_num(); // TODO: rename inode appropriately auto inode = iv.inode_num();
os << indent << "<inode:" << inode << "> " << modestring(mode); os << indent << "<inode:" << inode << "> " << modestring(mode);
@ -520,15 +519,15 @@ void metadata_<LoggerPolicy>::dump(
auto cr = get_chunk_range(inode); auto cr = get_chunk_range(inode);
DWARFS_CHECK(cr, "invalid chunk range"); DWARFS_CHECK(cr, "invalid chunk range");
os << " [" << cr->begin_ << ", " << cr->end_ << "]"; os << " [" << cr->begin_ << ", " << cr->end_ << "]";
os << " " << file_size(inode_data, mode) << "\n"; os << " " << file_size(iv, mode) << "\n";
if (detail_level > 3) { if (detail_level > 3) {
icb(indent + " ", inode); icb(indent + " ", inode);
} }
} else if (S_ISDIR(mode)) { } else if (S_ISDIR(mode)) {
dump(os, indent + " ", make_directory_view(inode_data), entry, dump(os, indent + " ", make_directory_view(iv), entry, detail_level,
detail_level, std::move(icb)); std::move(icb));
} else if (S_ISLNK(mode)) { } else if (S_ISLNK(mode)) {
os << " -> " << link_value(inode_data) << "\n"; os << " -> " << link_value(iv) << "\n";
} else if (S_ISBLK(mode)) { } else if (S_ISBLK(mode)) {
os << " (block device: " << get_device_id(inode) << ")\n"; os << " (block device: " << get_device_id(inode) << ")\n";
} else if (S_ISCHR(mode)) { } else if (S_ISCHR(mode)) {
@ -642,9 +641,9 @@ template <typename LoggerPolicy>
folly::dynamic metadata_<LoggerPolicy>::as_dynamic(dir_entry_view entry) const { folly::dynamic metadata_<LoggerPolicy>::as_dynamic(dir_entry_view entry) const {
folly::dynamic obj = folly::dynamic::object; folly::dynamic obj = folly::dynamic::object;
auto inode_data = entry.inode(); auto iv = entry.inode();
auto mode = inode_data.mode(); auto mode = iv.mode();
auto inode = inode_data.inode_num(); // TODO: rename all the things auto inode = iv.inode_num();
obj["mode"] = mode; obj["mode"] = mode;
obj["modestring"] = modestring(mode); obj["modestring"] = modestring(mode);
@ -656,13 +655,13 @@ folly::dynamic metadata_<LoggerPolicy>::as_dynamic(dir_entry_view entry) const {
if (S_ISREG(mode)) { if (S_ISREG(mode)) {
obj["type"] = "file"; obj["type"] = "file";
obj["size"] = file_size(inode_data, mode); obj["size"] = file_size(iv, mode);
} else if (S_ISDIR(mode)) { } else if (S_ISDIR(mode)) {
obj["type"] = "directory"; obj["type"] = "directory";
obj["inodes"] = as_dynamic(make_directory_view(inode_data), entry); obj["inodes"] = as_dynamic(make_directory_view(iv), entry);
} else if (S_ISLNK(mode)) { } else if (S_ISLNK(mode)) {
obj["type"] = "link"; obj["type"] = "link";
obj["target"] = std::string(link_value(inode_data)); obj["target"] = std::string(link_value(iv));
} else if (S_ISBLK(mode)) { } else if (S_ISBLK(mode)) {
obj["type"] = "blockdev"; obj["type"] = "blockdev";
obj["device_id"] = get_device_id(inode); obj["device_id"] = get_device_id(inode);
@ -734,16 +733,16 @@ void metadata_<LoggerPolicy>::walk(uint32_t self_index, uint32_t parent_index,
func(self_index, parent_index); func(self_index, parent_index);
auto entry = make_dir_entry_view(self_index, parent_index); auto entry = make_dir_entry_view(self_index, parent_index);
auto inode_data = entry.inode(); auto iv = entry.inode();
if (S_ISDIR(inode_data.mode())) { if (S_ISDIR(iv.mode())) {
auto inode = inode_data.inode_num(); auto inode = iv.inode_num();
if (!seen.emplace(inode).second) { if (!seen.emplace(inode).second) {
DWARFS_THROW(runtime_error, "cycle detected during directory walk"); DWARFS_THROW(runtime_error, "cycle detected during directory walk");
} }
auto dir = make_directory_view(inode_data); auto dir = make_directory_view(iv);
for (auto cur_index : dir.entry_range()) { for (auto cur_index : dir.entry_range()) {
walk(cur_index, self_index, seen, func); walk(cur_index, self_index, seen, func);
@ -843,22 +842,22 @@ metadata_<LoggerPolicy>::find(const char* path) const {
++path; ++path;
} }
std::optional<inode_view> entry = root_.inode(); std::optional<inode_view> iv = root_.inode();
while (*path) { while (*path) {
const char* next = ::strchr(path, '/'); const char* next = ::strchr(path, '/');
size_t clen = next ? next - path : ::strlen(path); size_t clen = next ? next - path : ::strlen(path);
entry = find(make_directory_view(*entry), std::string_view(path, clen)); iv = find(make_directory_view(*iv), std::string_view(path, clen));
if (!entry) { if (!iv) {
break; break;
} }
path = next ? next + 1 : path + clen; path = next ? next + 1 : path + clen;
} }
return entry; return iv;
} }
template <typename LoggerPolicy> template <typename LoggerPolicy>
@ -869,23 +868,23 @@ std::optional<inode_view> metadata_<LoggerPolicy>::find(int inode) const {
template <typename LoggerPolicy> template <typename LoggerPolicy>
std::optional<inode_view> std::optional<inode_view>
metadata_<LoggerPolicy>::find(int inode, const char* name) const { metadata_<LoggerPolicy>::find(int inode, const char* name) const {
auto entry = get_entry(inode); auto iv = get_entry(inode);
if (entry) { if (iv) {
entry = find(make_directory_view(*entry), std::string_view(name)); iv = find(make_directory_view(*iv), std::string_view(name));
} }
return entry; return iv;
} }
template <typename LoggerPolicy> template <typename LoggerPolicy>
int metadata_<LoggerPolicy>::getattr(inode_view entry, int metadata_<LoggerPolicy>::getattr(inode_view iv,
struct ::stat* stbuf) const { struct ::stat* stbuf) const {
::memset(stbuf, 0, sizeof(*stbuf)); ::memset(stbuf, 0, sizeof(*stbuf));
auto mode = entry.mode(); auto mode = iv.mode();
auto timebase = meta_.timestamp_base(); auto timebase = meta_.timestamp_base();
auto inode = entry.inode_num(); auto inode = iv.inode_num();
bool mtime_only = meta_.options() && meta_.options()->mtime_only(); bool mtime_only = meta_.options() && meta_.options()->mtime_only();
uint32_t resolution = 1; uint32_t resolution = 1;
if (meta_.options()) { if (meta_.options()) {
@ -901,17 +900,17 @@ int metadata_<LoggerPolicy>::getattr(inode_view entry,
stbuf->st_mode &= READ_ONLY_MASK; stbuf->st_mode &= READ_ONLY_MASK;
} }
stbuf->st_size = S_ISDIR(mode) ? make_directory_view(entry).entry_count() stbuf->st_size = S_ISDIR(mode) ? make_directory_view(iv).entry_count()
: file_size(entry, mode); : file_size(iv, mode);
stbuf->st_ino = inode + inode_offset_; stbuf->st_ino = inode + inode_offset_;
stbuf->st_blocks = (stbuf->st_size + 511) / 512; stbuf->st_blocks = (stbuf->st_size + 511) / 512;
stbuf->st_uid = entry.getuid(); stbuf->st_uid = iv.getuid();
stbuf->st_gid = entry.getgid(); stbuf->st_gid = iv.getgid();
stbuf->st_mtime = resolution * (timebase + entry.mtime_offset()); stbuf->st_mtime = resolution * (timebase + iv.mtime_offset());
stbuf->st_atime = mtime_only ? stbuf->st_mtime stbuf->st_atime = mtime_only ? stbuf->st_mtime
: resolution * (timebase + entry.atime_offset()); : resolution * (timebase + iv.atime_offset());
stbuf->st_ctime = mtime_only ? stbuf->st_mtime stbuf->st_ctime = mtime_only ? stbuf->st_mtime
: resolution * (timebase + entry.ctime_offset()); : resolution * (timebase + iv.ctime_offset());
stbuf->st_nlink = options_.enable_nlink && S_ISREG(mode) stbuf->st_nlink = options_.enable_nlink && S_ISREG(mode)
? DWARFS_NOTHROW(nlinks_.at(inode - file_inode_offset_)) ? DWARFS_NOTHROW(nlinks_.at(inode - file_inode_offset_))
: 1; : 1;
@ -925,11 +924,11 @@ int metadata_<LoggerPolicy>::getattr(inode_view entry,
template <typename LoggerPolicy> template <typename LoggerPolicy>
std::optional<directory_view> std::optional<directory_view>
metadata_<LoggerPolicy>::opendir(inode_view entry) const { metadata_<LoggerPolicy>::opendir(inode_view iv) const {
std::optional<directory_view> rv; std::optional<directory_view> rv;
if (S_ISDIR(entry.mode())) { if (S_ISDIR(iv.mode())) {
rv = make_directory_view(entry); rv = make_directory_view(iv);
} }
return rv; return rv;
@ -961,7 +960,7 @@ metadata_<LoggerPolicy>::readdir(directory_view dir, size_t offset) const {
} }
template <typename LoggerPolicy> template <typename LoggerPolicy>
int metadata_<LoggerPolicy>::access(inode_view entry, int mode, uid_t uid, int metadata_<LoggerPolicy>::access(inode_view iv, int mode, uid_t uid,
gid_t gid) const { gid_t gid) const {
if (mode == F_OK) { if (mode == F_OK) {
// easy; we're only interested in the file's existance // easy; we're only interested in the file's existance
@ -969,7 +968,7 @@ int metadata_<LoggerPolicy>::access(inode_view entry, int mode, uid_t uid,
} }
int access_mode = 0; int access_mode = 0;
int e_mode = entry.mode(); int e_mode = iv.mode();
auto test = [e_mode, &access_mode](uint16_t r_bit, uint16_t x_bit) { auto test = [e_mode, &access_mode](uint16_t r_bit, uint16_t x_bit) {
if (e_mode & r_bit) { if (e_mode & r_bit) {
@ -980,14 +979,14 @@ int metadata_<LoggerPolicy>::access(inode_view entry, int mode, uid_t uid,
} }
}; };
// Let's build the entry's access mask // Let's build the inode's access mask
test(S_IROTH, S_IXOTH); test(S_IROTH, S_IXOTH);
if (entry.getgid() == gid) { if (iv.getgid() == gid) {
test(S_IRGRP, S_IXGRP); test(S_IRGRP, S_IXGRP);
} }
if (entry.getuid() == uid) { if (iv.getuid() == uid) {
test(S_IRUSR, S_IXUSR); test(S_IRUSR, S_IXUSR);
} }
@ -995,19 +994,18 @@ int metadata_<LoggerPolicy>::access(inode_view entry, int mode, uid_t uid,
} }
template <typename LoggerPolicy> template <typename LoggerPolicy>
int metadata_<LoggerPolicy>::open(inode_view entry) const { int metadata_<LoggerPolicy>::open(inode_view iv) const {
if (S_ISREG(entry.mode())) { if (S_ISREG(iv.mode())) {
return entry.inode_num(); return iv.inode_num();
} }
return -1; return -1;
} }
template <typename LoggerPolicy> template <typename LoggerPolicy>
int metadata_<LoggerPolicy>::readlink(inode_view entry, int metadata_<LoggerPolicy>::readlink(inode_view iv, std::string* buf) const {
std::string* buf) const { if (S_ISLNK(iv.mode())) {
if (S_ISLNK(entry.mode())) { buf->assign(link_value(iv));
buf->assign(link_value(entry));
return 0; return 0;
} }
@ -1016,9 +1014,9 @@ int metadata_<LoggerPolicy>::readlink(inode_view entry,
template <typename LoggerPolicy> template <typename LoggerPolicy>
folly::Expected<std::string_view, int> folly::Expected<std::string_view, int>
metadata_<LoggerPolicy>::readlink(inode_view entry) const { metadata_<LoggerPolicy>::readlink(inode_view iv) const {
if (S_ISLNK(entry.mode())) { if (S_ISLNK(iv.mode())) {
return link_value(entry); return link_value(iv);
} }
return folly::makeUnexpected(-EINVAL); return folly::makeUnexpected(-EINVAL);