mirror of
https://github.com/facebook/sapling.git
synced 2024-10-09 16:31:02 +03:00
ee7b9b71e8
Summary: This diff adds a gflag option to turn on `TreeOverlay`. As this diff, this option only works on Windows. Reviewed By: xavierd Differential Revision: D25223471 fbshipit-source-id: ccab4c85cf4b08980e67814238457a8eb83af3dc
614 lines
19 KiB
C++
614 lines
19 KiB
C++
/*
|
|
* Copyright (c) Facebook, Inc. and its affiliates.
|
|
*
|
|
* This software may be used and distributed according to the terms of the
|
|
* GNU General Public License version 2.
|
|
*/
|
|
|
|
#include "eden/fs/inodes/Overlay.h"
|
|
|
|
#include <boost/filesystem.hpp>
|
|
#include <algorithm>
|
|
|
|
#include <folly/Exception.h>
|
|
#include <folly/File.h>
|
|
#include <folly/FileUtil.h>
|
|
#include <folly/Range.h>
|
|
#include <folly/io/Cursor.h>
|
|
#include <folly/io/IOBuf.h>
|
|
#include <folly/logging/xlog.h>
|
|
#include <folly/stop_watch.h>
|
|
#include <thrift/lib/cpp2/protocol/Serializer.h>
|
|
#include "eden/fs/inodes/DirEntry.h"
|
|
#include "eden/fs/inodes/InodeBase.h"
|
|
#include "eden/fs/inodes/TreeInode.h"
|
|
#include "eden/fs/inodes/treeoverlay/TreeOverlay.h"
|
|
#include "eden/fs/utils/Bug.h"
|
|
#include "eden/fs/utils/PathFuncs.h"
|
|
|
|
#ifndef _WIN32
|
|
#include "eden/fs/inodes/InodeTable.h"
|
|
#include "eden/fs/inodes/OverlayFile.h"
|
|
#endif // !_WIN32
|
|
|
|
DEFINE_bool(use_tree_overlay, false, "[experimental] use TreeOverlay");
|
|
|
|
namespace facebook {
|
|
namespace eden {
|
|
|
|
namespace {
|
|
constexpr uint64_t ioCountMask = 0x7FFFFFFFFFFFFFFFull;
|
|
constexpr uint64_t ioClosedMask = 1ull << 63;
|
|
|
|
std::unique_ptr<IOverlay> makeOverlay(AbsolutePathPiece localDir) {
|
|
if (FLAGS_use_tree_overlay) {
|
|
return std::make_unique<TreeOverlay>(localDir);
|
|
}
|
|
#ifdef _WIN32
|
|
return std::make_unique<SqliteOverlay>(localDir);
|
|
#else
|
|
return std::make_unique<FsOverlay>(localDir);
|
|
#endif
|
|
}
|
|
} // namespace
|
|
|
|
using folly::Unit;
|
|
using std::optional;
|
|
|
|
std::shared_ptr<Overlay> Overlay::create(
|
|
AbsolutePathPiece localDir,
|
|
bool caseSensitive,
|
|
std::shared_ptr<StructuredLogger> logger) {
|
|
struct MakeSharedEnabler : public Overlay {
|
|
explicit MakeSharedEnabler(
|
|
AbsolutePathPiece localDir,
|
|
bool caseSensitive,
|
|
std::shared_ptr<StructuredLogger> logger)
|
|
: Overlay(localDir, caseSensitive, logger) {}
|
|
};
|
|
return std::make_shared<MakeSharedEnabler>(localDir, caseSensitive, logger);
|
|
}
|
|
|
|
Overlay::Overlay(
|
|
AbsolutePathPiece localDir,
|
|
bool caseSensitive,
|
|
std::shared_ptr<StructuredLogger> logger)
|
|
: backingOverlay_{makeOverlay(localDir)},
|
|
supportsSemanticOperations_{
|
|
backingOverlay_->supportsSemanticOperations()},
|
|
caseSensitive_{caseSensitive},
|
|
structuredLogger_{logger} {}
|
|
|
|
Overlay::~Overlay() {
|
|
close();
|
|
}
|
|
|
|
void Overlay::close() {
|
|
XCHECK_NE(std::this_thread::get_id(), gcThread_.get_id());
|
|
|
|
gcQueue_.lock()->stop = true;
|
|
gcCondVar_.notify_one();
|
|
if (gcThread_.joinable()) {
|
|
gcThread_.join();
|
|
}
|
|
|
|
// Make sure everything is shut down in reverse of construction order.
|
|
// Cleanup is not necessary if overlay was not initialized
|
|
if (!backingOverlay_->initialized()) {
|
|
return;
|
|
}
|
|
|
|
// Since we are closing the overlay, no other threads can still be using
|
|
// it. They must have used some external synchronization mechanism to
|
|
// ensure this, so it is okay for us to still use relaxed access to
|
|
// nextInodeNumber_.
|
|
std::optional<InodeNumber> optNextInodeNumber;
|
|
auto nextInodeNumber = nextInodeNumber_.load(std::memory_order_relaxed);
|
|
if (nextInodeNumber) {
|
|
optNextInodeNumber = InodeNumber{nextInodeNumber};
|
|
}
|
|
|
|
closeAndWaitForOutstandingIO();
|
|
#ifndef _WIN32
|
|
inodeMetadataTable_.reset();
|
|
#endif // !_WIN32
|
|
|
|
backingOverlay_->close(optNextInodeNumber);
|
|
}
|
|
|
|
bool Overlay::isClosed() {
|
|
return outstandingIORequests_.load(std::memory_order_acquire) & ioClosedMask;
|
|
}
|
|
|
|
#ifndef _WIN32
|
|
struct statfs Overlay::statFs() {
|
|
IORequest req{this};
|
|
return backingOverlay_->statFs();
|
|
}
|
|
#endif // !_WIN32
|
|
|
|
folly::SemiFuture<Unit> Overlay::initialize(
|
|
OverlayChecker::ProgressCallback&& progressCallback) {
|
|
// The initOverlay() call is potentially slow, so we want to avoid
|
|
// performing it in the current thread and blocking returning to our caller.
|
|
//
|
|
// We already spawn a separate thread for garbage collection. It's convenient
|
|
// to simply use this existing thread to perform the initialization logic
|
|
// before waiting for GC work to do.
|
|
auto [initPromise, initFuture] = folly::makePromiseContract<Unit>();
|
|
|
|
gcThread_ = std::thread([this,
|
|
progressCallback = std::move(progressCallback),
|
|
promise = std::move(initPromise)]() mutable {
|
|
try {
|
|
initOverlay(progressCallback);
|
|
} catch (std::exception& ex) {
|
|
XLOG(ERR) << "overlay initialization failed for "
|
|
<< backingOverlay_->getLocalDir() << ": " << ex.what();
|
|
promise.setException(
|
|
folly::exception_wrapper(std::current_exception(), ex));
|
|
return;
|
|
}
|
|
promise.setValue();
|
|
#ifndef _WIN32
|
|
// TODO: On Windows files are cached by the ProjectedFS. We need to
|
|
// clean the cached files while doing GC.
|
|
|
|
gcThread();
|
|
#endif
|
|
});
|
|
return std::move(initFuture);
|
|
}
|
|
|
|
void Overlay::initOverlay(
|
|
const OverlayChecker::ProgressCallback& progressCallback) {
|
|
IORequest req{this};
|
|
auto optNextInodeNumber = backingOverlay_->initOverlay(true);
|
|
if (!optNextInodeNumber.has_value()) {
|
|
#ifndef _WIN32
|
|
// If the next-inode-number data is missing it means that this overlay was
|
|
// not shut down cleanly the last time it was used. If this was caused by a
|
|
// hard system reboot this can sometimes cause corruption and/or missing
|
|
// data in some of the on-disk state.
|
|
//
|
|
// Use OverlayChecker to scan the overlay for any issues, and also compute
|
|
// correct next inode number as it does so.
|
|
XLOG(WARN) << "Overlay " << backingOverlay_->getLocalDir()
|
|
<< " was not shut down cleanly. Performing fsck scan.";
|
|
|
|
// TODO(zeyi): `OverlayCheck` should be associated with the specific
|
|
// Overlay implementation. `reinterpret_cast` is a temporary workaround.
|
|
OverlayChecker checker(
|
|
reinterpret_cast<FsOverlay*>(backingOverlay_.get()), std::nullopt);
|
|
folly::stop_watch<> fsckRuntime;
|
|
checker.scanForErrors(progressCallback);
|
|
auto result = checker.repairErrors();
|
|
auto fsckRuntimeInSeconds =
|
|
std::chrono::duration<double>{fsckRuntime.elapsed()}.count();
|
|
if (result) {
|
|
// If totalErrors - fixedErrors is nonzero, then we failed to
|
|
// fix all of the problems.
|
|
auto success = !(result->totalErrors - result->fixedErrors);
|
|
structuredLogger_->logEvent(
|
|
Fsck{fsckRuntimeInSeconds, success, true /*attempted_repair*/});
|
|
} else {
|
|
structuredLogger_->logEvent(Fsck{
|
|
fsckRuntimeInSeconds, true /*success*/, false /*attempted_repair*/});
|
|
}
|
|
|
|
optNextInodeNumber = checker.getNextInodeNumber();
|
|
#else
|
|
// SqliteOverlay will always return the value of next Inode number, if we
|
|
// end up here - it's a bug.
|
|
EDEN_BUG() << "Sqlite Overlay is null value for NextInodeNumber";
|
|
#endif
|
|
} else {
|
|
hadCleanStartup_ = true;
|
|
}
|
|
nextInodeNumber_.store(optNextInodeNumber->get(), std::memory_order_relaxed);
|
|
|
|
#ifndef _WIN32
|
|
// Open after infoFile_'s lock is acquired because the InodeTable acquires
|
|
// its own lock, which should be released prior to infoFile_.
|
|
inodeMetadataTable_ =
|
|
InodeMetadataTable::open((backingOverlay_->getLocalDir() +
|
|
PathComponentPiece{FsOverlay::kMetadataFile})
|
|
.c_str());
|
|
#endif // !_WIN32
|
|
}
|
|
|
|
InodeNumber Overlay::allocateInodeNumber() {
|
|
// InodeNumber should generally be 64-bits wide, in which case it isn't even
|
|
// worth bothering to handle the case where nextInodeNumber_ wraps. We don't
|
|
// need to bother checking for conflicts with existing inode numbers since
|
|
// this can only happen if we wrap around. We don't currently support
|
|
// platforms with 32-bit inode numbers.
|
|
static_assert(
|
|
sizeof(nextInodeNumber_) == sizeof(InodeNumber),
|
|
"expected nextInodeNumber_ and InodeNumber to have the same size");
|
|
static_assert(
|
|
sizeof(InodeNumber) >= 8, "expected InodeNumber to be at least 64 bits");
|
|
|
|
// This could be a relaxed atomic operation. It doesn't matter on x86 but
|
|
// might on ARM.
|
|
auto previous = nextInodeNumber_++;
|
|
#ifdef _WIN32
|
|
backingOverlay_->updateUsedInodeNumber(previous);
|
|
#endif
|
|
XDCHECK_NE(0u, previous) << "allocateInodeNumber called before initialize";
|
|
return InodeNumber{previous};
|
|
}
|
|
|
|
DirContents Overlay::loadOverlayDir(InodeNumber inodeNumber) {
|
|
DirContents result(caseSensitive_);
|
|
IORequest req{this};
|
|
auto dirData = backingOverlay_->loadOverlayDir(inodeNumber);
|
|
if (!dirData.has_value()) {
|
|
return result;
|
|
}
|
|
const auto& dir = dirData.value();
|
|
|
|
bool shouldMigrateToNewFormat = false;
|
|
|
|
for (auto& iter : *dir.entries_ref()) {
|
|
const auto& name = iter.first;
|
|
const auto& value = iter.second;
|
|
|
|
InodeNumber ino;
|
|
if (*value.inodeNumber_ref()) {
|
|
ino = InodeNumber::fromThrift(*value.inodeNumber_ref());
|
|
} else {
|
|
ino = allocateInodeNumber();
|
|
shouldMigrateToNewFormat = true;
|
|
}
|
|
|
|
if (value.hash_ref() && !value.hash_ref()->empty()) {
|
|
auto hash = Hash{folly::ByteRange{folly::StringPiece{*value.hash_ref()}}};
|
|
result.emplace(PathComponentPiece{name}, *value.mode_ref(), ino, hash);
|
|
} else {
|
|
// The inode is materialized
|
|
result.emplace(PathComponentPiece{name}, *value.mode_ref(), ino);
|
|
}
|
|
}
|
|
|
|
if (shouldMigrateToNewFormat) {
|
|
saveOverlayDir(inodeNumber, result);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
overlay::OverlayEntry Overlay::serializeOverlayEntry(const DirEntry& ent) {
|
|
overlay::OverlayEntry entry;
|
|
|
|
// TODO: Eventually, we should only serialize the child entry's dtype into
|
|
// the Overlay. But, as of now, it's possible to create an inode under a
|
|
// tree, serialize that tree into the overlay, then restart Eden. Since
|
|
// writing mode bits into the InodeMetadataTable only occurs when the inode
|
|
// is loaded, the initial mode bits must persist until the first load.
|
|
entry.mode_ref() = ent.getInitialMode();
|
|
entry.inodeNumber_ref() = ent.getInodeNumber().get();
|
|
if (!ent.isMaterialized()) {
|
|
entry.hash_ref() = ent.getHash().toByteString();
|
|
}
|
|
|
|
return entry;
|
|
}
|
|
|
|
overlay::OverlayDir Overlay::serializeOverlayDir(
|
|
InodeNumber inodeNumber,
|
|
const DirContents& dir) {
|
|
IORequest req{this};
|
|
auto nextInodeNumber = nextInodeNumber_.load(std::memory_order_relaxed);
|
|
XCHECK_LT(inodeNumber.get(), nextInodeNumber)
|
|
<< "serializeOverlayDir called with unallocated inode number";
|
|
|
|
// TODO: T20282158 clean up access of child inode information.
|
|
//
|
|
// Translate the data to the thrift equivalents
|
|
overlay::OverlayDir odir;
|
|
|
|
for (auto& entIter : dir) {
|
|
const auto& entName = entIter.first;
|
|
const auto& ent = entIter.second;
|
|
|
|
XCHECK_NE(entName, "")
|
|
<< "serializeOverlayDir called with entry with an empty path for directory with inodeNumber="
|
|
<< inodeNumber;
|
|
XCHECK_LT(ent.getInodeNumber().get(), nextInodeNumber)
|
|
<< "serializeOverlayDir called with entry using unallocated inode number";
|
|
|
|
odir.entries_ref()->emplace(std::make_pair(
|
|
entName.stringPiece().str(), serializeOverlayEntry(ent)));
|
|
}
|
|
|
|
return odir;
|
|
}
|
|
|
|
void Overlay::saveOverlayDir(InodeNumber inodeNumber, const DirContents& dir) {
|
|
backingOverlay_->saveOverlayDir(
|
|
inodeNumber, serializeOverlayDir(inodeNumber, dir));
|
|
}
|
|
|
|
void Overlay::removeOverlayData(InodeNumber inodeNumber) {
|
|
IORequest req{this};
|
|
|
|
#ifndef _WIN32
|
|
// TODO: batch request during GC
|
|
getInodeMetadataTable()->freeInode(inodeNumber);
|
|
#endif // !_WIN32
|
|
backingOverlay_->removeOverlayData(inodeNumber);
|
|
}
|
|
|
|
#ifndef _WIN32
|
|
void Overlay::recursivelyRemoveOverlayData(InodeNumber inodeNumber) {
|
|
IORequest req{this};
|
|
auto dirData = backingOverlay_->loadOverlayDir(inodeNumber);
|
|
|
|
// This inode's data must be removed from the overlay before
|
|
// recursivelyRemoveOverlayData returns to avoid a race condition if
|
|
// recursivelyRemoveOverlayData(I) is called immediately prior to
|
|
// saveOverlayDir(I). There's also no risk of violating our durability
|
|
// guarantees if the process dies after this call but before the thread could
|
|
// remove this data.
|
|
removeOverlayData(inodeNumber);
|
|
|
|
if (dirData) {
|
|
gcQueue_.lock()->queue.emplace_back(std::move(*dirData));
|
|
gcCondVar_.notify_one();
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifndef _WIN32
|
|
folly::Future<folly::Unit> Overlay::flushPendingAsync() {
|
|
folly::Promise<folly::Unit> promise;
|
|
auto future = promise.getFuture();
|
|
gcQueue_.lock()->queue.emplace_back(std::move(promise));
|
|
gcCondVar_.notify_one();
|
|
return future;
|
|
}
|
|
#endif // !_WIN32
|
|
|
|
bool Overlay::hasOverlayData(InodeNumber inodeNumber) {
|
|
IORequest req{this};
|
|
return backingOverlay_->hasOverlayData(inodeNumber);
|
|
}
|
|
|
|
#ifndef _WIN32
|
|
// Helper function to open,validate,
|
|
// get file pointer of an overlay file
|
|
OverlayFile Overlay::openFile(
|
|
InodeNumber inodeNumber,
|
|
folly::StringPiece headerId) {
|
|
IORequest req{this};
|
|
return OverlayFile(
|
|
backingOverlay_->openFile(inodeNumber, headerId), weak_from_this());
|
|
}
|
|
|
|
OverlayFile Overlay::openFileNoVerify(InodeNumber inodeNumber) {
|
|
IORequest req{this};
|
|
return OverlayFile(
|
|
backingOverlay_->openFileNoVerify(inodeNumber), weak_from_this());
|
|
}
|
|
|
|
OverlayFile Overlay::createOverlayFile(
|
|
InodeNumber inodeNumber,
|
|
folly::ByteRange contents) {
|
|
IORequest req{this};
|
|
XCHECK_LT(inodeNumber.get(), nextInodeNumber_.load(std::memory_order_relaxed))
|
|
<< "createOverlayFile called with unallocated inode number";
|
|
return OverlayFile(
|
|
backingOverlay_->createOverlayFile(inodeNumber, contents),
|
|
weak_from_this());
|
|
}
|
|
|
|
OverlayFile Overlay::createOverlayFile(
|
|
InodeNumber inodeNumber,
|
|
const folly::IOBuf& contents) {
|
|
IORequest req{this};
|
|
XCHECK_LT(inodeNumber.get(), nextInodeNumber_.load(std::memory_order_relaxed))
|
|
<< "createOverlayFile called with unallocated inode number";
|
|
return OverlayFile(
|
|
backingOverlay_->createOverlayFile(inodeNumber, contents),
|
|
weak_from_this());
|
|
}
|
|
|
|
#endif // !_WIN32
|
|
|
|
InodeNumber Overlay::getMaxInodeNumber() {
|
|
auto ino = nextInodeNumber_.load(std::memory_order_relaxed);
|
|
XCHECK_GT(ino, 1u);
|
|
return InodeNumber{ino - 1};
|
|
}
|
|
|
|
bool Overlay::tryIncOutstandingIORequests() {
|
|
uint64_t currentOutstandingIO =
|
|
outstandingIORequests_.load(std::memory_order_seq_cst);
|
|
|
|
// Retry incrementing the IO count while we have not either successfully
|
|
// updated outstandingIORequests_ or closed the overlay
|
|
while (!(currentOutstandingIO & ioClosedMask)) {
|
|
// If not closed, currentOutstandingIO now holds what
|
|
// outstandingIORequests_ actually contained
|
|
if (outstandingIORequests_.compare_exchange_weak(
|
|
currentOutstandingIO,
|
|
currentOutstandingIO + 1,
|
|
std::memory_order_seq_cst)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// If we have broken out of the above loop, the overlay is closed and we
|
|
// been unable to increment outstandingIORequests_.
|
|
return false;
|
|
}
|
|
|
|
void Overlay::decOutstandingIORequests() {
|
|
uint64_t outstanding =
|
|
outstandingIORequests_.fetch_sub(1, std::memory_order_seq_cst);
|
|
XCHECK_NE(0ull, outstanding) << "Decremented too far!";
|
|
// If the overlay is closed and we just finished our last IO request (meaning
|
|
// the previous value of outstandingIORequests_ was 1), then wake the waiting
|
|
// thread.
|
|
if ((outstanding & ioClosedMask) && (outstanding & ioCountMask) == 1) {
|
|
lastOutstandingRequestIsComplete_.post();
|
|
}
|
|
}
|
|
|
|
void Overlay::closeAndWaitForOutstandingIO() {
|
|
uint64_t outstanding =
|
|
outstandingIORequests_.fetch_or(ioClosedMask, std::memory_order_seq_cst);
|
|
|
|
// If we have outstanding IO requests, wait for them. This should not block if
|
|
// this baton has already been posted between the load in the fetch_or and
|
|
// this if statement.
|
|
if (outstanding & ioCountMask) {
|
|
lastOutstandingRequestIsComplete_.wait();
|
|
}
|
|
}
|
|
|
|
#ifndef _WIN32
|
|
// TODO: On Windows files are cached by the ProjectedFS. We need to clean that
|
|
// cache before doing GC.
|
|
|
|
void Overlay::gcThread() noexcept {
|
|
for (;;) {
|
|
std::vector<GCRequest> requests;
|
|
{
|
|
auto lock = gcQueue_.lock();
|
|
while (lock->queue.empty()) {
|
|
if (lock->stop) {
|
|
return;
|
|
}
|
|
gcCondVar_.wait(lock.getUniqueLock());
|
|
continue;
|
|
}
|
|
|
|
requests = std::move(lock->queue);
|
|
}
|
|
|
|
for (auto& request : requests) {
|
|
try {
|
|
handleGCRequest(request);
|
|
} catch (const std::exception& e) {
|
|
XLOG(ERR) << "handleGCRequest should never throw, but it did: "
|
|
<< e.what();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Overlay::handleGCRequest(GCRequest& request) {
|
|
IORequest req{this};
|
|
if (request.flush) {
|
|
request.flush->setValue();
|
|
return;
|
|
}
|
|
|
|
// Should only include inode numbers for trees.
|
|
std::queue<InodeNumber> queue;
|
|
|
|
// TODO: For better throughput on large tree collections, it might make
|
|
// sense to split this into two threads: one for traversing the tree and
|
|
// another that makes the actual unlink calls.
|
|
auto safeRemoveOverlayData = [&](InodeNumber inodeNumber) {
|
|
try {
|
|
removeOverlayData(inodeNumber);
|
|
} catch (const std::exception& e) {
|
|
XLOG(ERR) << "Failed to remove overlay data for inode " << inodeNumber
|
|
<< ": " << e.what();
|
|
}
|
|
};
|
|
|
|
auto processDir = [&](const overlay::OverlayDir& dir) {
|
|
for (const auto& entry : *dir.entries_ref()) {
|
|
const auto& value = entry.second;
|
|
if (!(*value.inodeNumber_ref())) {
|
|
// Legacy-only. All new Overlay trees have inode numbers for all
|
|
// children.
|
|
continue;
|
|
}
|
|
auto ino = InodeNumber::fromThrift(*value.inodeNumber_ref());
|
|
|
|
if (S_ISDIR(*value.mode_ref())) {
|
|
queue.push(ino);
|
|
} else {
|
|
// No need to recurse, but delete any file at this inode. Note that,
|
|
// under normal operation, there should be nothing at this path
|
|
// because files are only written into the overlay if they're
|
|
// materialized.
|
|
safeRemoveOverlayData(ino);
|
|
}
|
|
}
|
|
};
|
|
|
|
processDir(request.dir);
|
|
|
|
while (!queue.empty()) {
|
|
auto ino = queue.front();
|
|
queue.pop();
|
|
|
|
overlay::OverlayDir dir;
|
|
try {
|
|
auto dirData = backingOverlay_->loadOverlayDir(ino);
|
|
if (!dirData.has_value()) {
|
|
XLOG(DBG7) << "no dir data for inode " << ino;
|
|
continue;
|
|
} else {
|
|
dir = std::move(*dirData);
|
|
}
|
|
} catch (const std::exception& e) {
|
|
XLOG(ERR) << "While collecting, failed to load tree data for inode "
|
|
<< ino << ": " << e.what();
|
|
continue;
|
|
}
|
|
|
|
safeRemoveOverlayData(ino);
|
|
processDir(dir);
|
|
}
|
|
}
|
|
#endif // !1
|
|
|
|
void Overlay::addChild(
|
|
InodeNumber parent,
|
|
const std::pair<PathComponent, DirEntry>& childEntry,
|
|
const DirContents& content) {
|
|
if (supportsSemanticOperations_) {
|
|
backingOverlay_->addChild(
|
|
parent, childEntry.first, serializeOverlayEntry(childEntry.second));
|
|
} else {
|
|
saveOverlayDir(parent, content);
|
|
}
|
|
}
|
|
|
|
void Overlay::removeChild(
|
|
InodeNumber parent,
|
|
PathComponentPiece childName,
|
|
const DirContents& content) {
|
|
if (supportsSemanticOperations_) {
|
|
backingOverlay_->removeChild(parent, childName);
|
|
} else {
|
|
saveOverlayDir(parent, content);
|
|
}
|
|
}
|
|
|
|
void Overlay::renameChild(
|
|
InodeNumber src,
|
|
InodeNumber dst,
|
|
PathComponentPiece srcName,
|
|
PathComponentPiece dstName,
|
|
const DirContents& srcContent,
|
|
const DirContents& dstContent) {
|
|
if (supportsSemanticOperations_) {
|
|
backingOverlay_->renameChild(src, dst, srcName, dstName);
|
|
} else {
|
|
saveOverlayDir(src, srcContent);
|
|
if (dst.get() != src.get()) {
|
|
saveOverlayDir(dst, dstContent);
|
|
}
|
|
}
|
|
}
|
|
} // namespace eden
|
|
} // namespace facebook
|