From 0d3cd059d7f9f37dcc8812e5e879502f4ec28283 Mon Sep 17 00:00:00 2001
From: Ben Langmuir <blangmuir@apple.com>
Date: Wed, 19 Feb 2014 03:29:17 +0000
Subject: [PATCH] Add an OverlayFileSystem class
Provides a way to merge multiple vfs::FileSystem objects into a single
filesystem.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@201635 91177308-0d34-0410-b5e6-96231b3b80d8
---
include/clang/Basic/VirtualFileSystem.h | 36 ++++
lib/Basic/VirtualFileSystem.cpp | 33 ++++
unittests/Basic/CMakeLists.txt | 1 +
unittests/Basic/VirtualFileSystemTest.cpp | 203 ++++++++++++++++++++++
4 files changed, 273 insertions(+)
create mode 100644 unittests/Basic/VirtualFileSystemTest.cpp
diff --git a/include/clang/Basic/VirtualFileSystem.h b/include/clang/Basic/VirtualFileSystem.h
index 9bd6b2bc63b..6dd9bf73b34 100644
--- a/include/clang/Basic/VirtualFileSystem.h
+++ b/include/clang/Basic/VirtualFileSystem.h
@@ -122,6 +122,42 @@ public:
/// the operating system.
llvm::IntrusiveRefCntPtr<FileSystem> getRealFileSystem();
+/// \brief A file system that allows overlaying one \p AbstractFileSystem on top
+/// of another.
+///
+/// Consists of a stack of >=1 \p FileSytem objects, which are treated as being
+/// one merged file system. When there is a directory that exists in more than
+/// one file system, the \p OverlayFileSystem contains a directory containing
+/// the union of their contents. The attributes (permissions, etc.) of the
+/// top-most (most recently added) directory are used. When there is a file
+/// that exists in more than one file system, the file in the top-most file
+/// system overrides the other(s).
+class OverlayFileSystem : public FileSystem {
+ typedef llvm::SmallVector<llvm::IntrusiveRefCntPtr<FileSystem>, 1>
+ FileSystemList;
+ typedef FileSystemList::reverse_iterator iterator;
+
+ /// \brief The stack of file systems, implemented as a list in order of
+ /// their addition.
+ FileSystemList FSList;
+
+ /// \brief Get an iterator pointing to the most recently added file system.
+ iterator overlays_begin() { return FSList.rbegin(); }
+
+ /// \brief Get an iterator pointing one-past the least recently added file
+ /// system.
+ iterator overlays_end() { return FSList.rend(); }
+
+public:
+ OverlayFileSystem(llvm::IntrusiveRefCntPtr<FileSystem> Base);
+ /// \brief Pushes a file system on top of the stack.
+ void pushOverlay(llvm::IntrusiveRefCntPtr<FileSystem> FS);
+
+ llvm::ErrorOr<Status> status(const llvm::Twine &Path) LLVM_OVERRIDE;
+ llvm::error_code openFileForRead(const llvm::Twine &Path,
+ llvm::OwningPtr<File> &Result) LLVM_OVERRIDE;
+};
+
} // end namespace vfs
} // end namespace clang
#endif // LLVM_CLANG_BASIC_VIRTUAL_FILE_SYSTEM_H
diff --git a/lib/Basic/VirtualFileSystem.cpp b/lib/Basic/VirtualFileSystem.cpp
index 0345ed153e3..7afdac864b9 100644
--- a/lib/Basic/VirtualFileSystem.cpp
+++ b/lib/Basic/VirtualFileSystem.cpp
@@ -160,3 +160,36 @@ IntrusiveRefCntPtr<FileSystem> vfs::getRealFileSystem() {
static IntrusiveRefCntPtr<FileSystem> FS = new RealFileSystem();
return FS;
}
+
+//===-----------------------------------------------------------------------===/
+// OverlayFileSystem implementation
+//===-----------------------------------------------------------------------===/
+OverlayFileSystem::OverlayFileSystem(
+ IntrusiveRefCntPtr<FileSystem> BaseFS) {
+ pushOverlay(BaseFS);
+}
+
+void OverlayFileSystem::pushOverlay(IntrusiveRefCntPtr<FileSystem> FS) {
+ FSList.push_back(FS);
+}
+
+ErrorOr<Status> OverlayFileSystem::status(const Twine &Path) {
+ // FIXME: handle symlinks that cross file systems
+ for (iterator I = overlays_begin(), E = overlays_end(); I != E; ++I) {
+ ErrorOr<Status> Status = (*I)->status(Path);
+ if (Status || Status.getError() != errc::no_such_file_or_directory)
+ return Status;
+ }
+ return error_code(errc::no_such_file_or_directory, system_category());
+}
+
+error_code OverlayFileSystem::openFileForRead(const llvm::Twine &Path,
+ OwningPtr<File> &Result) {
+ // FIXME: handle symlinks that cross file systems
+ for (iterator I = overlays_begin(), E = overlays_end(); I != E; ++I) {
+ error_code EC = (*I)->openFileForRead(Path, Result);
+ if (!EC || EC != errc::no_such_file_or_directory)
+ return EC;
+ }
+ return error_code(errc::no_such_file_or_directory, system_category());
+}
diff --git a/unittests/Basic/CMakeLists.txt b/unittests/Basic/CMakeLists.txt
index e8b766cc8a2..b8f69bf357b 100644
--- a/unittests/Basic/CMakeLists.txt
+++ b/unittests/Basic/CMakeLists.txt
@@ -6,6 +6,7 @@ add_clang_unittest(BasicTests
CharInfoTest.cpp
FileManagerTest.cpp
SourceManagerTest.cpp
+ VirtualFileSystemTest.cpp
)
target_link_libraries(BasicTests
diff --git a/unittests/Basic/VirtualFileSystemTest.cpp b/unittests/Basic/VirtualFileSystemTest.cpp
new file mode 100644
index 00000000000..a82a55bda0a
--- /dev/null
+++ b/unittests/Basic/VirtualFileSystemTest.cpp
@@ -0,0 +1,203 @@
+//===- unittests/Basic/VirtualFileSystem.cpp ---------------- VFS tests ---===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Basic/VirtualFileSystem.h"
+#include "llvm/Support/Path.h"
+#include "gtest/gtest.h"
+#include <map>
+using namespace clang;
+using namespace llvm;
+using llvm::sys::fs::UniqueID;
+
+namespace {
+class DummyFileSystem : public vfs::FileSystem {
+ int FSID; // used to produce UniqueIDs
+ int FileID; // used to produce UniqueIDs
+ std::map<std::string, vfs::Status> FilesAndDirs;
+
+ static int getNextFSID() {
+ static int Count = 0;
+ return Count++;
+ }
+
+public:
+ DummyFileSystem() : FSID(getNextFSID()), FileID(0) {}
+
+ ErrorOr<vfs::Status> status(const Twine &Path) {
+ std::map<std::string, vfs::Status>::iterator I =
+ FilesAndDirs.find(Path.str());
+ if (I == FilesAndDirs.end())
+ return error_code(errc::no_such_file_or_directory, posix_category());
+ return I->second;
+ }
+ error_code openFileForRead(const Twine &Path, OwningPtr<vfs::File> &Result) {
+ llvm_unreachable("unimplemented");
+ }
+ error_code getBufferForFile(const Twine &Name,
+ OwningPtr<MemoryBuffer> &Result,
+ int64_t FileSize = -1,
+ bool RequiresNullTerminator = true) {
+ llvm_unreachable("unimplemented");
+ }
+
+ void addEntry(StringRef Path, const vfs::Status &Status) {
+ FilesAndDirs[Path] = Status;
+ }
+
+ void addRegularFile(StringRef Path, sys::fs::perms Perms=sys::fs::all_all) {
+ vfs::Status S(Path, Path, UniqueID(FSID, FileID++), sys::TimeValue::now(),
+ 0, 0, 1024, sys::fs::file_type::regular_file, Perms);
+ addEntry(Path, S);
+ }
+
+ void addDirectory(StringRef Path, sys::fs::perms Perms=sys::fs::all_all) {
+ vfs::Status S(Path, Path, UniqueID(FSID, FileID++), sys::TimeValue::now(),
+ 0, 0, 0, sys::fs::file_type::directory_file, Perms);
+ addEntry(Path, S);
+ }
+
+ void addSymlink(StringRef Path) {
+ vfs::Status S(Path, Path, UniqueID(FSID, FileID++), sys::TimeValue::now(),
+ 0, 0, 0, sys::fs::file_type::symlink_file, sys::fs::all_all);
+ addEntry(Path, S);
+ }
+};
+} // end anonymous namespace
+
+TEST(VirtualFileSystemTest, status_queries) {
+ IntrusiveRefCntPtr<DummyFileSystem> D(new DummyFileSystem());
+ ErrorOr<vfs::Status> Status((error_code()));
+
+ D->addRegularFile("/foo");
+ ASSERT_TRUE(Status = D->status("/foo"));
+ EXPECT_TRUE(Status->isStatusKnown());
+ EXPECT_FALSE(Status->isDirectory());
+ EXPECT_TRUE(Status->isRegularFile());
+ EXPECT_FALSE(Status->isSymlink());
+ EXPECT_FALSE(Status->isOther());
+ EXPECT_TRUE(Status->exists());
+
+ D->addDirectory("/bar");
+ ASSERT_TRUE(Status = D->status("/bar"));
+ EXPECT_TRUE(Status->isStatusKnown());
+ EXPECT_TRUE(Status->isDirectory());
+ EXPECT_FALSE(Status->isRegularFile());
+ EXPECT_FALSE(Status->isSymlink());
+ EXPECT_FALSE(Status->isOther());
+ EXPECT_TRUE(Status->exists());
+
+ D->addSymlink("/baz");
+ ASSERT_TRUE(Status = D->status("/baz"));
+ EXPECT_TRUE(Status->isStatusKnown());
+ EXPECT_FALSE(Status->isDirectory());
+ EXPECT_FALSE(Status->isRegularFile());
+ EXPECT_TRUE(Status->isSymlink());
+ EXPECT_FALSE(Status->isOther());
+ EXPECT_TRUE(Status->exists());
+
+ EXPECT_TRUE(Status->equivalent(*Status));
+ ErrorOr<vfs::Status> Status2((error_code()));
+ ASSERT_TRUE(Status2 = D->status("/foo"));
+ EXPECT_FALSE(Status->equivalent(*Status2));
+}
+
+TEST(VirtualFileSystemTest, base_only_overlay) {
+ IntrusiveRefCntPtr<DummyFileSystem> D(new DummyFileSystem());
+ ErrorOr<vfs::Status> Status((error_code()));
+ EXPECT_FALSE(Status = D->status("/foo"));
+
+ IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(new vfs::OverlayFileSystem(D));
+ EXPECT_FALSE(Status = O->status("/foo"));
+
+ D->addRegularFile("/foo");
+ EXPECT_TRUE(Status = D->status("/foo"));
+
+ ErrorOr<vfs::Status> Status2((error_code()));
+ EXPECT_TRUE(Status2 = O->status("/foo"));
+ EXPECT_TRUE(Status->equivalent(*Status2));
+}
+
+TEST(VirtualFileSystemTest, overlay_files) {
+ IntrusiveRefCntPtr<DummyFileSystem> Base(new DummyFileSystem());
+ IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem());
+ IntrusiveRefCntPtr<DummyFileSystem> Top(new DummyFileSystem());
+ IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(new vfs::OverlayFileSystem(Base));
+ O->pushOverlay(Middle);
+ O->pushOverlay(Top);
+
+ ErrorOr<vfs::Status> Status1((error_code())), Status2((error_code())),
+ Status3((error_code())), StatusB((error_code())),
+ StatusM((error_code())), StatusT((error_code()));
+
+ Base->addRegularFile("/foo");
+ ASSERT_TRUE(StatusB = Base->status("/foo"));
+ ASSERT_TRUE(Status1 = O->status("/foo"));
+ Middle->addRegularFile("/foo");
+ ASSERT_TRUE(StatusM = Middle->status("/foo"));
+ ASSERT_TRUE(Status2 = O->status("/foo"));
+ Top->addRegularFile("/foo");
+ ASSERT_TRUE(StatusT = Top->status("/foo"));
+ ASSERT_TRUE(Status3 = O->status("/foo"));
+
+ EXPECT_TRUE(Status1->equivalent(*StatusB));
+ EXPECT_TRUE(Status2->equivalent(*StatusM));
+ EXPECT_TRUE(Status3->equivalent(*StatusT));
+
+ EXPECT_FALSE(Status1->equivalent(*Status2));
+ EXPECT_FALSE(Status2->equivalent(*Status3));
+ EXPECT_FALSE(Status1->equivalent(*Status3));
+}
+
+TEST(VirtualFileSystemTest, overlay_dirs) {
+ IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
+ IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
+ IntrusiveRefCntPtr<vfs::OverlayFileSystem>
+ O(new vfs::OverlayFileSystem(Lower));
+ O->pushOverlay(Upper);
+
+ ErrorOr<vfs::Status> Status1((error_code())), Status2((error_code())),
+ Status3((error_code()));
+
+ Lower->addDirectory("/lower-only");
+ Lower->addDirectory("/both");
+ Upper->addDirectory("/both");
+ Upper->addDirectory("/upper-only");
+
+ // non-merged paths should be the same
+ ASSERT_TRUE(Status1 = Lower->status("/lower-only"));
+ ASSERT_TRUE(Status2 = O->status("/lower-only"));
+ EXPECT_TRUE(Status1->equivalent(*Status2));
+
+ ASSERT_TRUE(Status1 = Lower->status("/lower-only"));
+ ASSERT_TRUE(Status2 = O->status("/lower-only"));
+ EXPECT_TRUE(Status1->equivalent(*Status2));
+}
+
+TEST(VirtualFileSystemTest, permissions) {
+ // merged directories get the permissions of the upper dir
+ IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
+ IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
+ IntrusiveRefCntPtr<vfs::OverlayFileSystem>
+ O(new vfs::OverlayFileSystem(Lower));
+ O->pushOverlay(Upper);
+
+ ErrorOr<vfs::Status> Status((error_code()));
+ Lower->addDirectory("/both", sys::fs::owner_read);
+ Upper->addDirectory("/both", sys::fs::owner_all | sys::fs::group_read);
+ ASSERT_TRUE(Status = O->status("/both"));
+ EXPECT_EQ(0740, Status->getPermissions());
+
+ // permissions (as usual) are not recursively applied
+ Lower->addRegularFile("/both/foo", sys::fs::owner_read);
+ Upper->addRegularFile("/both/bar", sys::fs::owner_write);
+ ASSERT_TRUE(Status = O->status("/both/foo"));
+ EXPECT_EQ(0400, Status->getPermissions());
+ ASSERT_TRUE(Status = O->status("/both/bar"));
+ EXPECT_EQ(0200, Status->getPermissions());
+}
--
GitLab