From 6c03a38d81cc87645850843824824c2ae1defd32 Mon Sep 17 00:00:00 2001 From: Juergen Ributzka Date: Thu, 20 Feb 2014 05:24:58 +0000 Subject: [PATCH] Reverting the virtual file system implementation, because it triggers an assertion in our internal build bots. This reverts commits 201618, 201635, 201636, 201639, 201685, 201691, and 201696. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@201755 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/Basic/FileManager.h | 34 ++-- include/clang/Basic/FileSystemStatCache.h | 23 +-- include/clang/Basic/VirtualFileSystem.h | 162 ---------------- include/clang/Frontend/CompilerInstance.h | 24 --- lib/Basic/CMakeLists.txt | 1 - lib/Basic/FileManager.cpp | 86 +++++---- lib/Basic/FileSystemStatCache.cpp | 44 +++-- lib/Basic/VirtualFileSystem.cpp | 193 ------------------- lib/Frontend/ASTUnit.cpp | 6 +- lib/Frontend/CacheTokens.cpp | 4 +- lib/Frontend/ChainedIncludesSource.cpp | 1 - lib/Frontend/CompilerInstance.cpp | 9 +- lib/Frontend/FrontendAction.cpp | 3 +- lib/Lex/PTHLexer.cpp | 4 +- lib/Serialization/ModuleManager.cpp | 2 +- unittests/Basic/CMakeLists.txt | 1 - unittests/Basic/FileManagerTest.cpp | 2 +- unittests/Basic/VirtualFileSystemTest.cpp | 216 ---------------------- 18 files changed, 108 insertions(+), 707 deletions(-) delete mode 100644 include/clang/Basic/VirtualFileSystem.h delete mode 100644 lib/Basic/VirtualFileSystem.cpp delete mode 100644 unittests/Basic/VirtualFileSystemTest.cpp diff --git a/include/clang/Basic/FileManager.h b/include/clang/Basic/FileManager.h index c2d78eed52..5f22481855 100644 --- a/include/clang/Basic/FileManager.h +++ b/include/clang/Basic/FileManager.h @@ -17,7 +17,6 @@ #include "clang/Basic/FileSystemOptions.h" #include "clang/Basic/LLVM.h" -#include "clang/Basic/VirtualFileSystem.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/OwningPtr.h" @@ -25,6 +24,7 @@ #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" #include "llvm/Support/Allocator.h" +#include "llvm/Support/FileSystem.h" // FIXME: Enhance libsystem to support inode and other fields in stat. #include @@ -55,7 +55,7 @@ public: /// \brief Cached information about one file (either on disk /// or in the virtual file system). /// -/// If the 'File' member is valid, then this FileEntry has an open file +/// If the 'FD' member is valid, then this FileEntry has an open file /// descriptor for the file. class FileEntry { const char *Name; // Name of the file. @@ -67,33 +67,31 @@ class FileEntry { bool IsNamedPipe; bool InPCH; - /// \brief The open file, if it is owned by the \p FileEntry. - mutable OwningPtr File; + /// FD - The file descriptor for the file entry if it is opened and owned + /// by the FileEntry. If not, this is set to -1. + mutable int FD; friend class FileManager; - void closeFile() const { - File.reset(0); // rely on destructor to close File - } - public: FileEntry(llvm::sys::fs::UniqueID UniqueID, bool IsNamedPipe, bool InPCH) - : Name(0), UniqueID(UniqueID), IsNamedPipe(IsNamedPipe), InPCH(InPCH) - {} + : Name(0), UniqueID(UniqueID), IsNamedPipe(IsNamedPipe), InPCH(InPCH), + FD(-1) {} // Add a default constructor for use with llvm::StringMap FileEntry() - : Name(0), UniqueID(0, 0), IsNamedPipe(false), InPCH(false) - {} + : Name(0), UniqueID(0, 0), IsNamedPipe(false), InPCH(false), FD(-1) {} FileEntry(const FileEntry &FE) { memcpy(this, &FE, sizeof(FE)); - assert(!File && "Cannot copy a file-owning FileEntry"); + assert(FD == -1 && "Cannot copy a file-owning FileEntry"); } void operator=(const FileEntry &FE) { memcpy(this, &FE, sizeof(FE)); - assert(!File && "Cannot assign a file-owning FileEntry"); + assert(FD == -1 && "Cannot assign a file-owning FileEntry"); } + ~FileEntry(); + const char *getName() const { return Name; } off_t getSize() const { return Size; } unsigned getUID() const { return UID; } @@ -121,7 +119,6 @@ struct FileData; /// as a single file. /// class FileManager : public RefCountedBase { - IntrusiveRefCntPtr FS; FileSystemOptions FileSystemOpts; class UniqueDirContainer; @@ -175,15 +172,14 @@ class FileManager : public RefCountedBase { OwningPtr StatCache; bool getStatValue(const char *Path, FileData &Data, bool isFile, - vfs::File **F); + int *FileDescriptor); /// Add all ancestors of the given path (pointing to either a file /// or a directory) as virtual directories. void addAncestorsAsVirtualDirs(StringRef Path); public: - FileManager(const FileSystemOptions &FileSystemOpts, - IntrusiveRefCntPtr FS = 0); + FileManager(const FileSystemOptions &FileSystemOpts); ~FileManager(); /// \brief Installs the provided FileSystemStatCache object within @@ -252,7 +248,7 @@ public: /// /// \returns false on success, true on error. bool getNoncachedStatValue(StringRef Path, - vfs::Status &Result); + llvm::sys::fs::file_status &Result); /// \brief Remove the real file \p Entry from the cache. void invalidateCache(const FileEntry *Entry); diff --git a/include/clang/Basic/FileSystemStatCache.h b/include/clang/Basic/FileSystemStatCache.h index 913e41e4ca..23d8256943 100644 --- a/include/clang/Basic/FileSystemStatCache.h +++ b/include/clang/Basic/FileSystemStatCache.h @@ -24,11 +24,6 @@ namespace clang { -namespace vfs { -class File; -class FileSystem; -} - struct FileData { uint64_t Size; time_t ModTime; @@ -62,11 +57,10 @@ public: /// If isFile is true, then this lookup should only return success for files /// (not directories). If it is false this lookup should only return /// success for directories (not files). On a successful file lookup, the - /// implementation can optionally fill in \p F with a valid \p File object and - /// the client guarantees that it will close it. + /// implementation can optionally fill in FileDescriptor with a valid + /// descriptor and the client guarantees that it will close it. static bool get(const char *Path, FileData &Data, bool isFile, - vfs::File **F, FileSystemStatCache *Cache, - vfs::FileSystem &FS); + int *FileDescriptor, FileSystemStatCache *Cache); /// \brief Sets the next stat call cache in the chain of stat caches. /// Takes ownership of the given stat cache. @@ -84,16 +78,17 @@ public: protected: virtual LookupResult getStat(const char *Path, FileData &Data, bool isFile, - vfs::File **F, vfs::FileSystem &FS) = 0; + int *FileDescriptor) = 0; LookupResult statChained(const char *Path, FileData &Data, bool isFile, - vfs::File **F, vfs::FileSystem &FS) { + int *FileDescriptor) { if (FileSystemStatCache *Next = getNextStatCache()) - return Next->getStat(Path, Data, isFile, F, FS); + return Next->getStat(Path, Data, isFile, FileDescriptor); // If we hit the end of the list of stat caches to try, just compute and // return it without a cache. - return get(Path, Data, isFile, F, 0, FS) ? CacheMissing : CacheExists; + return get(Path, Data, isFile, FileDescriptor, 0) ? CacheMissing + : CacheExists; } }; @@ -112,7 +107,7 @@ public: iterator end() const { return StatCalls.end(); } virtual LookupResult getStat(const char *Path, FileData &Data, bool isFile, - vfs::File **F, vfs::FileSystem &FS); + int *FileDescriptor); }; } // end namespace clang diff --git a/include/clang/Basic/VirtualFileSystem.h b/include/clang/Basic/VirtualFileSystem.h deleted file mode 100644 index 694c6ddec8..0000000000 --- a/include/clang/Basic/VirtualFileSystem.h +++ /dev/null @@ -1,162 +0,0 @@ -//===- VirtualFileSystem.h - Virtual File System Layer ----------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -/// \file -/// \brief Defines the virtual file system interface vfs::FileSystem. -//===----------------------------------------------------------------------===// - -#ifndef LLVM_CLANG_BASIC_VIRTUAL_FILE_SYSTEM_H -#define LLVM_CLANG_BASIC_VIRTUAL_FILE_SYSTEM_H - -#include "clang/Basic/LLVM.h" -#include "llvm/ADT/IntrusiveRefCntPtr.h" -#include "llvm/Support/FileSystem.h" -#include "llvm/Support/ErrorOr.h" - -namespace llvm { -class MemoryBuffer; -} - -namespace clang { -namespace vfs { - -/// \brief The result of a \p status operation. -class Status { - std::string Name; - std::string ExternalName; - llvm::sys::fs::UniqueID UID; - llvm::sys::TimeValue MTime; - uint32_t User; - uint32_t Group; - uint64_t Size; - llvm::sys::fs::file_type Type; - llvm::sys::fs::perms Perms; - -public: - Status() : Type(llvm::sys::fs::file_type::status_error) {} - Status(const llvm::sys::fs::file_status &Status); - Status(StringRef Name, StringRef RealName, llvm::sys::fs::UniqueID UID, - llvm::sys::TimeValue MTime, uint32_t User, uint32_t Group, - uint64_t Size, llvm::sys::fs::file_type Type, - llvm::sys::fs::perms Perms); - - /// \brief Returns the name this status was looked up by. - StringRef getName() const { return Name; } - - /// \brief Returns the name to use outside the compiler. - /// - /// For example, in diagnostics or debug info we should use this name. - StringRef getExternalName() const { return ExternalName; } - - void setName(StringRef N) { Name = N; } - void setExternalName(StringRef N) { ExternalName = N; } - - /// @name Status interface from llvm::sys::fs - /// @{ - llvm::sys::fs::file_type getType() const { return Type; } - llvm::sys::fs::perms getPermissions() const { return Perms; } - llvm::sys::TimeValue getLastModificationTime() const { return MTime; } - llvm::sys::fs::UniqueID getUniqueID() const { return UID; } - uint32_t getUser() const { return User; } - uint32_t getGroup() const { return Group; } - uint64_t getSize() const { return Size; } - void setType(llvm::sys::fs::file_type v) { Type = v; } - void setPermissions(llvm::sys::fs::perms p) { Perms = p; } - /// @} - /// @name Status queries - /// These are static queries in llvm::sys::fs. - /// @{ - bool equivalent(const Status &Other) const; - bool isDirectory() const; - bool isRegularFile() const; - bool isOther() const; - bool isSymlink() const; - bool isStatusKnown() const; - bool exists() const; - /// @} -}; - -/// \brief Represents an open file. -class File { -public: - /// \brief Destroy the file after closing it (if open). - /// Sub-classes should generally call close() inside their destructors. We - /// cannot do that from the base class, since close is virtual. - virtual ~File(); - /// \brief Get the status of the file. - virtual llvm::ErrorOr status() = 0; - /// \brief Get the contents of the file as a \p MemoryBuffer. - virtual llvm::error_code getBuffer(const Twine &Name, - OwningPtr &Result, - int64_t FileSize = -1, - bool RequiresNullTerminator = true) = 0; - /// \brief Closes the file. - virtual llvm::error_code close() = 0; -}; - -/// \brief The virtual file system interface. -class FileSystem : public RefCountedBase { -public: - virtual ~FileSystem(); - - /// \brief Get the status of the entry at \p Path, if one exists. - virtual llvm::ErrorOr status(const Twine &Path) = 0; - /// \brief Get a \p File object for the file at \p Path, if one exists. - virtual llvm::error_code openFileForRead(const Twine &Path, - OwningPtr &Result) = 0; - - /// This is a convenience method that opens a file, gets its content and then - /// closes the file. - llvm::error_code getBufferForFile(const Twine &Name, - OwningPtr &Result, - int64_t FileSize = -1, - bool RequiresNullTerminator = true); -}; - -/// \brief Gets an \p vfs::FileSystem for the 'real' file system, as seen by -/// the operating system. -IntrusiveRefCntPtr 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 SmallVector, 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(IntrusiveRefCntPtr Base); - /// \brief Pushes a file system on top of the stack. - void pushOverlay(IntrusiveRefCntPtr FS); - - llvm::ErrorOr status(const Twine &Path) LLVM_OVERRIDE; - llvm::error_code openFileForRead(const Twine &Path, - OwningPtr &Result) LLVM_OVERRIDE; -}; - -} // end namespace vfs -} // end namespace clang -#endif // LLVM_CLANG_BASIC_VIRTUAL_FILE_SYSTEM_H diff --git a/include/clang/Frontend/CompilerInstance.h b/include/clang/Frontend/CompilerInstance.h index 8cfc8ee1d2..fa20ae48e4 100644 --- a/include/clang/Frontend/CompilerInstance.h +++ b/include/clang/Frontend/CompilerInstance.h @@ -75,9 +75,6 @@ class CompilerInstance : public ModuleLoader { /// The target being compiled for. IntrusiveRefCntPtr Target; - /// The virtual file system. - IntrusiveRefCntPtr VirtualFileSystem; - /// The file manager. IntrusiveRefCntPtr FileMgr; @@ -316,23 +313,6 @@ public: /// Replace the current diagnostics engine. void setTarget(TargetInfo *Value); - /// } - /// @name Virtual File System - /// { - - bool hasVirtualFileSystem() const { return VirtualFileSystem != 0; } - - vfs::FileSystem &getVirtualFileSystem() const { - assert(hasVirtualFileSystem() && - "Compiler instance has no virtual file system"); - return *VirtualFileSystem; - } - - /// \brief Replace the current virtual file system. - void setVirtualFileSystem(IntrusiveRefCntPtr FS) { - VirtualFileSystem = FS; - } - /// } /// @name File Manager /// { @@ -547,10 +527,6 @@ public: bool ShouldOwnClient = true, const CodeGenOptions *CodeGenOpts = 0); - /// Create a virtual file system and replace any existing one with it. - /// The default is to use the real file system. - void createVirtualFileSystem(); - /// Create the file manager and replace any existing one with it. void createFileManager(); diff --git a/lib/Basic/CMakeLists.txt b/lib/Basic/CMakeLists.txt index 2efe8127b9..43622eb33d 100644 --- a/lib/Basic/CMakeLists.txt +++ b/lib/Basic/CMakeLists.txt @@ -23,7 +23,6 @@ add_clang_library(clangBasic TokenKinds.cpp Version.cpp VersionTuple.cpp - VirtualFileSystem.cpp ) # Determine Subversion revision. diff --git a/lib/Basic/FileManager.cpp b/lib/Basic/FileManager.cpp index 08f19fb200..af9b2663cb 100644 --- a/lib/Basic/FileManager.cpp +++ b/lib/Basic/FileManager.cpp @@ -30,6 +30,19 @@ #include #include +// FIXME: This is terrible, we need this for ::close. +#if !defined(_MSC_VER) && !defined(__MINGW32__) +#include +#include +#else +#include +#ifndef S_ISFIFO +#define S_ISFIFO(x) (0) +#endif +#endif +#if defined(LLVM_ON_UNIX) +#include +#endif using namespace clang; // FIXME: Enhance libsystem to support inode and other fields. @@ -44,6 +57,12 @@ using namespace clang; #define NON_EXISTENT_FILE reinterpret_cast((intptr_t)-1) +FileEntry::~FileEntry() { + // If this FileEntry owns an open file descriptor that never got used, close + // it. + if (FD != -1) ::close(FD); +} + class FileManager::UniqueDirContainer { /// UniqueDirs - Cache from ID's to existing directories/files. std::map UniqueDirs; @@ -82,19 +101,13 @@ public: // Common logic. //===----------------------------------------------------------------------===// -FileManager::FileManager(const FileSystemOptions &FSO, - IntrusiveRefCntPtr FS) - : FS(FS), FileSystemOpts(FSO), +FileManager::FileManager(const FileSystemOptions &FSO) + : FileSystemOpts(FSO), UniqueRealDirs(*new UniqueDirContainer()), UniqueRealFiles(*new UniqueFileContainer()), SeenDirEntries(64), SeenFileEntries(64), NextFileUID(0) { NumDirLookups = NumFileLookups = 0; NumDirCacheMisses = NumFileCacheMisses = 0; - - // If the caller doesn't provide a virtual file system, just grab the real - // file system. - if (!FS) - this->FS = vfs::getRealFileSystem(); } FileManager::~FileManager() { @@ -296,9 +309,10 @@ const FileEntry *FileManager::getFile(StringRef Filename, bool openFile, // FIXME: This will reduce the # syscalls. // Nope, there isn't. Check to see if the file exists. - vfs::File *F = 0; + int FileDescriptor = -1; FileData Data; - if (getStatValue(InterndFileName, Data, true, openFile ? &F : 0)) { + if (getStatValue(InterndFileName, Data, true, + openFile ? &FileDescriptor : 0)) { // There's no real file at the given path. if (!CacheFailure) SeenFileEntries.erase(Filename); @@ -306,7 +320,10 @@ const FileEntry *FileManager::getFile(StringRef Filename, bool openFile, return 0; } - assert(openFile || !F && "undesired open file"); + if (FileDescriptor != -1 && !openFile) { + close(FileDescriptor); + FileDescriptor = -1; + } // It exists. See if we have already opened a file with the same inode. // This occurs when one dir is symlinked to another, for example. @@ -316,8 +333,8 @@ const FileEntry *FileManager::getFile(StringRef Filename, bool openFile, NamedFileEnt.setValue(&UFE); if (UFE.getName()) { // Already have an entry with this inode, return it. // If the stat process opened the file, close it to avoid a FD leak. - if (F) - delete F; + if (FileDescriptor != -1) + close(FileDescriptor); return &UFE; } @@ -330,7 +347,7 @@ const FileEntry *FileManager::getFile(StringRef Filename, bool openFile, UFE.ModTime = Data.ModTime; UFE.Dir = DirInfo; UFE.UID = NextFileUID++; - UFE.File.reset(F); + UFE.FD = FileDescriptor; return &UFE; } @@ -376,8 +393,10 @@ FileManager::getVirtualFile(StringRef Filename, off_t Size, // If we had already opened this file, close it now so we don't // leak the descriptor. We're not going to use the file // descriptor anyway, since this is a virtual file. - if (UFE->File) - UFE->closeFile(); + if (UFE->FD != -1) { + close(UFE->FD); + UFE->FD = -1; + } // If we already have an entry with this inode, return it. if (UFE->getName()) @@ -395,7 +414,7 @@ FileManager::getVirtualFile(StringRef Filename, off_t Size, UFE->ModTime = ModificationTime; UFE->Dir = DirInfo; UFE->UID = NextFileUID++; - UFE->File.reset(); + UFE->FD = -1; return UFE; } @@ -425,18 +444,20 @@ getBufferForFile(const FileEntry *Entry, std::string *ErrorStr, const char *Filename = Entry->getName(); // If the file is already open, use the open file descriptor. - if (Entry->File) { - ec = Entry->File->getBuffer(Filename, Result, FileSize); + if (Entry->FD != -1) { + ec = llvm::MemoryBuffer::getOpenFile(Entry->FD, Filename, Result, FileSize); if (ErrorStr) *ErrorStr = ec.message(); - Entry->closeFile(); + + close(Entry->FD); + Entry->FD = -1; return Result.take(); } // Otherwise, open the file. if (FileSystemOpts.WorkingDir.empty()) { - ec = FS->getBufferForFile(Filename, Result, FileSize); + ec = llvm::MemoryBuffer::getFile(Filename, Result, FileSize); if (ec && ErrorStr) *ErrorStr = ec.message(); return Result.take(); @@ -444,7 +465,7 @@ getBufferForFile(const FileEntry *Entry, std::string *ErrorStr, SmallString<128> FilePath(Entry->getName()); FixupRelativePath(FilePath); - ec = FS->getBufferForFile(FilePath.str(), Result, FileSize); + ec = llvm::MemoryBuffer::getFile(FilePath.str(), Result, FileSize); if (ec && ErrorStr) *ErrorStr = ec.message(); return Result.take(); @@ -455,7 +476,7 @@ getBufferForFile(StringRef Filename, std::string *ErrorStr) { OwningPtr Result; llvm::error_code ec; if (FileSystemOpts.WorkingDir.empty()) { - ec = FS->getBufferForFile(Filename, Result); + ec = llvm::MemoryBuffer::getFile(Filename, Result); if (ec && ErrorStr) *ErrorStr = ec.message(); return Result.take(); @@ -463,7 +484,7 @@ getBufferForFile(StringRef Filename, std::string *ErrorStr) { SmallString<128> FilePath(Filename); FixupRelativePath(FilePath); - ec = FS->getBufferForFile(FilePath.c_str(), Result); + ec = llvm::MemoryBuffer::getFile(FilePath.c_str(), Result); if (ec && ErrorStr) *ErrorStr = ec.message(); return Result.take(); @@ -475,29 +496,26 @@ getBufferForFile(StringRef Filename, std::string *ErrorStr) { /// false if it's an existent real file. If FileDescriptor is NULL, /// do directory look-up instead of file look-up. bool FileManager::getStatValue(const char *Path, FileData &Data, bool isFile, - vfs::File **F) { + int *FileDescriptor) { // FIXME: FileSystemOpts shouldn't be passed in here, all paths should be // absolute! if (FileSystemOpts.WorkingDir.empty()) - return FileSystemStatCache::get(Path, Data, isFile, F,StatCache.get(), *FS); + return FileSystemStatCache::get(Path, Data, isFile, FileDescriptor, + StatCache.get()); SmallString<128> FilePath(Path); FixupRelativePath(FilePath); - return FileSystemStatCache::get(FilePath.c_str(), Data, isFile, F, - StatCache.get(), *FS); + return FileSystemStatCache::get(FilePath.c_str(), Data, isFile, + FileDescriptor, StatCache.get()); } bool FileManager::getNoncachedStatValue(StringRef Path, - vfs::Status &Result) { + llvm::sys::fs::file_status &Result) { SmallString<128> FilePath(Path); FixupRelativePath(FilePath); - llvm::ErrorOr S = FS->status(FilePath.c_str()); - if (!S) - return true; - Result = *S; - return false; + return llvm::sys::fs::status(FilePath.c_str(), Result); } void FileManager::invalidateCache(const FileEntry *Entry) { diff --git a/lib/Basic/FileSystemStatCache.cpp b/lib/Basic/FileSystemStatCache.cpp index b225facbad..7a01bffcd9 100644 --- a/lib/Basic/FileSystemStatCache.cpp +++ b/lib/Basic/FileSystemStatCache.cpp @@ -12,7 +12,7 @@ //===----------------------------------------------------------------------===// #include "clang/Basic/FileSystemStatCache.h" -#include "clang/Basic/VirtualFileSystem.h" +#include "llvm/Support/FileSystem.h" #include "llvm/Support/Path.h" // FIXME: This is terrible, we need this for ::close. @@ -30,13 +30,13 @@ using namespace clang; void FileSystemStatCache::anchor() { } -static void copyStatusToFileData(const vfs::Status &Status, +static void copyStatusToFileData(const llvm::sys::fs::file_status &Status, FileData &Data) { Data.Size = Status.getSize(); Data.ModTime = Status.getLastModificationTime().toEpochTime(); Data.UniqueID = Status.getUniqueID(); - Data.IsDirectory = Status.isDirectory(); - Data.IsNamedPipe = Status.getType() == llvm::sys::fs::file_type::fifo_file; + Data.IsDirectory = is_directory(Status); + Data.IsNamedPipe = Status.type() == llvm::sys::fs::file_type::fifo_file; Data.InPCH = false; } @@ -50,23 +50,22 @@ static void copyStatusToFileData(const vfs::Status &Status, /// implementation can optionally fill in FileDescriptor with a valid /// descriptor and the client guarantees that it will close it. bool FileSystemStatCache::get(const char *Path, FileData &Data, bool isFile, - vfs::File **F, FileSystemStatCache *Cache, - vfs::FileSystem &FS) { + int *FileDescriptor, FileSystemStatCache *Cache) { LookupResult R; bool isForDir = !isFile; // If we have a cache, use it to resolve the stat query. if (Cache) - R = Cache->getStat(Path, Data, isFile, F, FS); - else if (isForDir || !F) { + R = Cache->getStat(Path, Data, isFile, FileDescriptor); + else if (isForDir || !FileDescriptor) { // If this is a directory or a file descriptor is not needed and we have // no cache, just go to the file system. - llvm::ErrorOr Status = FS.status(Path); - if (!Status) { + llvm::sys::fs::file_status Status; + if (llvm::sys::fs::status(Path, Status)) { R = CacheMissing; } else { R = CacheExists; - copyStatusToFileData(*Status, Data); + copyStatusToFileData(Status, Data); } } else { // Otherwise, we have to go to the filesystem. We can always just use @@ -76,8 +75,7 @@ bool FileSystemStatCache::get(const char *Path, FileData &Data, bool isFile, // // Because of this, check to see if the file exists with 'open'. If the // open succeeds, use fstat to get the stat info. - llvm::OwningPtr OwnedFile; - llvm::error_code EC = FS.openFileForRead(Path, OwnedFile); + llvm::error_code EC = llvm::sys::fs::openFileForRead(Path, *FileDescriptor); if (EC) { // If the open fails, our "stat" fails. @@ -86,16 +84,16 @@ bool FileSystemStatCache::get(const char *Path, FileData &Data, bool isFile, // Otherwise, the open succeeded. Do an fstat to get the information // about the file. We'll end up returning the open file descriptor to the // client to do what they please with it. - llvm::ErrorOr Status = OwnedFile->status(); - if (Status) { + llvm::sys::fs::file_status Status; + if (!llvm::sys::fs::status(*FileDescriptor, Status)) { R = CacheExists; - copyStatusToFileData(*Status, Data); - *F = OwnedFile.take(); + copyStatusToFileData(Status, Data); } else { // fstat rarely fails. If it does, claim the initial open didn't // succeed. R = CacheMissing; - *F = 0; + ::close(*FileDescriptor); + *FileDescriptor = -1; } } } @@ -107,9 +105,9 @@ bool FileSystemStatCache::get(const char *Path, FileData &Data, bool isFile, // demands. if (Data.IsDirectory != isForDir) { // If not, close the file if opened. - if (F && *F) { - (*F)->close(); - *F = 0; + if (FileDescriptor && *FileDescriptor != -1) { + ::close(*FileDescriptor); + *FileDescriptor = -1; } return true; @@ -120,8 +118,8 @@ bool FileSystemStatCache::get(const char *Path, FileData &Data, bool isFile, MemorizeStatCalls::LookupResult MemorizeStatCalls::getStat(const char *Path, FileData &Data, bool isFile, - vfs::File **F, vfs::FileSystem &FS) { - LookupResult Result = statChained(Path, Data, isFile, F, FS); + int *FileDescriptor) { + LookupResult Result = statChained(Path, Data, isFile, FileDescriptor); // Do not cache failed stats, it is easy to construct common inconsistent // situations if we do, and they are not important for PCH performance (which diff --git a/lib/Basic/VirtualFileSystem.cpp b/lib/Basic/VirtualFileSystem.cpp deleted file mode 100644 index 3fedf27f97..0000000000 --- a/lib/Basic/VirtualFileSystem.cpp +++ /dev/null @@ -1,193 +0,0 @@ -//===- VirtualFileSystem.cpp - Virtual File System Layer --------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// This file implements the VirtualFileSystem interface. -//===----------------------------------------------------------------------===// - -#include "clang/Basic/VirtualFileSystem.h" -#include "llvm/ADT/OwningPtr.h" -#include "llvm/Support/MemoryBuffer.h" -#include "llvm/Support/SourceMgr.h" -#include "llvm/Support/Path.h" - -using namespace clang; -using namespace clang::vfs; -using namespace llvm; -using llvm::sys::fs::file_status; -using llvm::sys::fs::file_type; -using llvm::sys::fs::perms; -using llvm::sys::fs::UniqueID; - -Status::Status(const file_status &Status) - : UID(Status.getUniqueID()), MTime(Status.getLastModificationTime()), - User(Status.getUser()), Group(Status.getGroup()), Size(Status.getSize()), - Type(Status.type()), Perms(Status.permissions()) {} - -Status::Status(StringRef Name, StringRef ExternalName, UniqueID UID, - sys::TimeValue MTime, uint32_t User, uint32_t Group, - uint64_t Size, file_type Type, perms Perms) - : Name(Name), ExternalName(ExternalName), UID(UID), MTime(MTime), - User(User), Group(Group), Size(Size), Type(Type), Perms(Perms) {} - -bool Status::equivalent(const Status &Other) const { - return getUniqueID() == Other.getUniqueID(); -} -bool Status::isDirectory() const { - return Type == file_type::directory_file; -} -bool Status::isRegularFile() const { - return Type == file_type::regular_file; -} -bool Status::isOther() const { - return exists() && !isRegularFile() && !isDirectory() && !isSymlink(); -} -bool Status::isSymlink() const { - return Type == file_type::symlink_file; -} -bool Status::isStatusKnown() const { - return Type != file_type::status_error; -} -bool Status::exists() const { - return isStatusKnown() && Type != file_type::file_not_found; -} - -File::~File() {} - -FileSystem::~FileSystem() {} - -error_code FileSystem::getBufferForFile(const llvm::Twine &Name, - OwningPtr &Result, - int64_t FileSize, - bool RequiresNullTerminator) { - llvm::OwningPtr F; - if (error_code EC = openFileForRead(Name, F)) - return EC; - - error_code EC = F->getBuffer(Name, Result, FileSize, RequiresNullTerminator); - return EC; -} - -//===-----------------------------------------------------------------------===/ -// RealFileSystem implementation -//===-----------------------------------------------------------------------===/ - -/// \brief Wrapper around a raw file descriptor. -class RealFile : public File { - int FD; - friend class RealFileSystem; - RealFile(int FD) : FD(FD) { - assert(FD >= 0 && "Invalid or inactive file descriptor"); - } -public: - ~RealFile(); - ErrorOr status() LLVM_OVERRIDE; - error_code getBuffer(const Twine &Name, OwningPtr &Result, - int64_t FileSize = -1, - bool RequiresNullTerminator = true) LLVM_OVERRIDE; - error_code close() LLVM_OVERRIDE; -}; -RealFile::~RealFile() { - close(); -} - -ErrorOr RealFile::status() { - assert(FD != -1 && "cannot stat closed file"); - file_status RealStatus; - if (error_code EC = sys::fs::status(FD, RealStatus)) - return EC; - return Status(RealStatus); -} - -error_code RealFile::getBuffer(const Twine &Name, - OwningPtr &Result, - int64_t FileSize, bool RequiresNullTerminator) { - assert(FD != -1 && "cannot get buffer for closed file"); - return MemoryBuffer::getOpenFile(FD, Name.str().c_str(), Result, FileSize, - RequiresNullTerminator); -} - -// FIXME: This is terrible, we need this for ::close. -#if !defined(_MSC_VER) && !defined(__MINGW32__) -#include -#include -#else -#include -#ifndef S_ISFIFO -#define S_ISFIFO(x) (0) -#endif -#endif -error_code RealFile::close() { - if (::close(FD)) - return error_code(errno, system_category()); - FD = -1; - return error_code::success(); -} - -/// \brief The file system according to your operating system. -class RealFileSystem : public FileSystem { -public: - ErrorOr status(const Twine &Path) LLVM_OVERRIDE; - error_code openFileForRead(const Twine &Path, - OwningPtr &Result) LLVM_OVERRIDE; -}; - -ErrorOr RealFileSystem::status(const Twine &Path) { - sys::fs::file_status RealStatus; - if (error_code EC = sys::fs::status(Path, RealStatus)) - return EC; - Status Result(RealStatus); - Result.setName(Path.str()); - Result.setExternalName(Path.str()); - return Result; -} - -error_code RealFileSystem::openFileForRead(const Twine &Name, - OwningPtr &Result) { - int FD; - if (error_code EC = sys::fs::openFileForRead(Name, FD)) - return EC; - Result.reset(new RealFile(FD)); - return error_code::success(); -} - -IntrusiveRefCntPtr vfs::getRealFileSystem() { - static IntrusiveRefCntPtr FS = new RealFileSystem(); - return FS; -} - -//===-----------------------------------------------------------------------===/ -// OverlayFileSystem implementation -//===-----------------------------------------------------------------------===/ -OverlayFileSystem::OverlayFileSystem(IntrusiveRefCntPtr BaseFS) { - pushOverlay(BaseFS); -} - -void OverlayFileSystem::pushOverlay(IntrusiveRefCntPtr FS) { - FSList.push_back(FS); -} - -ErrorOr 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 = (*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 &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/lib/Frontend/ASTUnit.cpp b/lib/Frontend/ASTUnit.cpp index 8d46a8f4a5..3fca309102 100644 --- a/lib/Frontend/ASTUnit.cpp +++ b/lib/Frontend/ASTUnit.cpp @@ -20,7 +20,6 @@ #include "clang/Basic/Diagnostic.h" #include "clang/Basic/TargetInfo.h" #include "clang/Basic/TargetOptions.h" -#include "clang/Basic/VirtualFileSystem.h" #include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/FrontendActions.h" #include "clang/Frontend/FrontendDiagnostic.h" @@ -38,6 +37,7 @@ #include "llvm/ADT/StringSet.h" #include "llvm/Support/Atomic.h" #include "llvm/Support/CrashRecoveryContext.h" +#include "llvm/Support/FileSystem.h" #include "llvm/Support/Host.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Mutex.h" @@ -1418,7 +1418,7 @@ llvm::MemoryBuffer *ASTUnit::getMainBufferWithPrecompiledPreamble( REnd = PreprocessorOpts.remapped_file_end(); !AnyFileChanged && R != REnd; ++R) { - vfs::Status Status; + llvm::sys::fs::file_status Status; if (FileMgr->getNoncachedStatValue(R->second, Status)) { // If we can't stat the file we're remapping to, assume that something // horrible happened. @@ -1454,7 +1454,7 @@ llvm::MemoryBuffer *ASTUnit::getMainBufferWithPrecompiledPreamble( } // The file was not remapped; check whether it has changed on disk. - vfs::Status Status; + llvm::sys::fs::file_status Status; if (FileMgr->getNoncachedStatValue(F->first(), Status)) { // If we can't stat the file, assume that something horrible happened. AnyFileChanged = true; diff --git a/lib/Frontend/CacheTokens.cpp b/lib/Frontend/CacheTokens.cpp index 5cb364e3f5..0c30b04957 100644 --- a/lib/Frontend/CacheTokens.cpp +++ b/lib/Frontend/CacheTokens.cpp @@ -516,8 +516,8 @@ public: ~StatListener() {} LookupResult getStat(const char *Path, FileData &Data, bool isFile, - vfs::File **F, vfs::FileSystem &FS) { - LookupResult Result = statChained(Path, Data, isFile, F, FS); + int *FileDescriptor) { + LookupResult Result = statChained(Path, Data, isFile, FileDescriptor); if (Result == CacheMissing) // Failed 'stat'. PM.insert(PTHEntryKeyVariant(Path), PTHEntry()); diff --git a/lib/Frontend/ChainedIncludesSource.cpp b/lib/Frontend/ChainedIncludesSource.cpp index d6d63bfb00..442177ec31 100644 --- a/lib/Frontend/ChainedIncludesSource.cpp +++ b/lib/Frontend/ChainedIncludesSource.cpp @@ -101,7 +101,6 @@ ChainedIncludesSource *ChainedIncludesSource::create(CompilerInstance &CI) { Clang->setDiagnostics(Diags.getPtr()); Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(), &Clang->getTargetOpts())); - Clang->createVirtualFileSystem(); Clang->createFileManager(); Clang->createSourceManager(Clang->getFileManager()); Clang->createPreprocessor(); diff --git a/lib/Frontend/CompilerInstance.cpp b/lib/Frontend/CompilerInstance.cpp index 5311c80497..61fe26c922 100644 --- a/lib/Frontend/CompilerInstance.cpp +++ b/lib/Frontend/CompilerInstance.cpp @@ -194,15 +194,10 @@ CompilerInstance::createDiagnostics(DiagnosticOptions *Opts, return Diags; } -void CompilerInstance::createVirtualFileSystem() { - VirtualFileSystem = vfs::getRealFileSystem(); -} - // File Manager void CompilerInstance::createFileManager() { - assert(hasVirtualFileSystem() && "expected virtual file system"); - FileMgr = new FileManager(getFileSystemOpts(), VirtualFileSystem); + FileMgr = new FileManager(getFileSystemOpts()); } // Source Manager @@ -872,8 +867,6 @@ static void compileModule(CompilerInstance &ImportingInstance, ImportingInstance.getDiagnosticClient()), /*ShouldOwnClient=*/true); - Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem()); - // Note that this module is part of the module build stack, so that we // can detect cycles in the module graph. Instance.createFileManager(); // FIXME: Adopt file manager from importer? diff --git a/lib/Frontend/FrontendAction.cpp b/lib/Frontend/FrontendAction.cpp index 4e04c2c0e8..0baf3e5e1f 100644 --- a/lib/Frontend/FrontendAction.cpp +++ b/lib/Frontend/FrontendAction.cpp @@ -159,6 +159,7 @@ ASTConsumer* FrontendAction::CreateWrappedASTConsumer(CompilerInstance &CI, return new MultiplexConsumer(Consumers); } + bool FrontendAction::BeginSourceFile(CompilerInstance &CI, const FrontendInputFile &Input) { assert(!Instance && "Already processing a source file!"); @@ -212,8 +213,6 @@ bool FrontendAction::BeginSourceFile(CompilerInstance &CI, } // Set up the file and source managers, if needed. - if (!CI.hasVirtualFileSystem()) - CI.createVirtualFileSystem(); if (!CI.hasFileManager()) CI.createFileManager(); if (!CI.hasSourceManager()) diff --git a/lib/Lex/PTHLexer.cpp b/lib/Lex/PTHLexer.cpp index cdc5d7e338..e174222ece 100644 --- a/lib/Lex/PTHLexer.cpp +++ b/lib/Lex/PTHLexer.cpp @@ -675,13 +675,13 @@ public: ~PTHStatCache() {} LookupResult getStat(const char *Path, FileData &Data, bool isFile, - vfs::File **F, vfs::FileSystem &FS) { + int *FileDescriptor) { // Do the lookup for the file's data in the PTH file. CacheTy::iterator I = Cache.find(Path); // If we don't get a hit in the PTH file just forward to 'stat'. if (I == Cache.end()) - return statChained(Path, Data, isFile, F, FS); + return statChained(Path, Data, isFile, FileDescriptor); const PTHStatData &D = *I; diff --git a/lib/Serialization/ModuleManager.cpp b/lib/Serialization/ModuleManager.cpp index ce7e7af3d1..711afcd2dc 100644 --- a/lib/Serialization/ModuleManager.cpp +++ b/lib/Serialization/ModuleManager.cpp @@ -89,7 +89,7 @@ ModuleManager::addModule(StringRef FileName, ModuleKind Type, New->InputFilesValidationTimestamp = 0; if (New->Kind == MK_Module) { std::string TimestampFilename = New->getTimestampFilename(); - vfs::Status Status; + llvm::sys::fs::file_status Status; // A cached stat value would be fine as well. if (!FileMgr.getNoncachedStatValue(TimestampFilename, Status)) New->InputFilesValidationTimestamp = diff --git a/unittests/Basic/CMakeLists.txt b/unittests/Basic/CMakeLists.txt index b8f69bf357..e8b766cc8a 100644 --- a/unittests/Basic/CMakeLists.txt +++ b/unittests/Basic/CMakeLists.txt @@ -6,7 +6,6 @@ add_clang_unittest(BasicTests CharInfoTest.cpp FileManagerTest.cpp SourceManagerTest.cpp - VirtualFileSystemTest.cpp ) target_link_libraries(BasicTests diff --git a/unittests/Basic/FileManagerTest.cpp b/unittests/Basic/FileManagerTest.cpp index 5b35e68735..f8ce50d531 100644 --- a/unittests/Basic/FileManagerTest.cpp +++ b/unittests/Basic/FileManagerTest.cpp @@ -48,7 +48,7 @@ public: // Implement FileSystemStatCache::getStat(). virtual LookupResult getStat(const char *Path, FileData &Data, bool isFile, - vfs::File **F, vfs::FileSystem &FS) { + int *FileDescriptor) { if (StatCalls.count(Path) != 0) { Data = StatCalls[Path]; return CacheExists; diff --git a/unittests/Basic/VirtualFileSystemTest.cpp b/unittests/Basic/VirtualFileSystemTest.cpp deleted file mode 100644 index e545e9c059..0000000000 --- a/unittests/Basic/VirtualFileSystemTest.cpp +++ /dev/null @@ -1,216 +0,0 @@ -//===- 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 -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 FilesAndDirs; - - static int getNextFSID() { - static int Count = 0; - return Count++; - } - -public: - DummyFileSystem() : FSID(getNextFSID()), FileID(0) {} - - ErrorOr status(const Twine &Path) { - std::map::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 &Result) { - llvm_unreachable("unimplemented"); - } - error_code getBufferForFile(const Twine &Name, - OwningPtr &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, statusQueries) { - IntrusiveRefCntPtr D(new DummyFileSystem()); - ErrorOr Status((error_code())); - - D->addRegularFile("/foo"); - Status = D->status("/foo"); - ASSERT_EQ(errc::success, Status.getError()); - 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"); - Status = D->status("/bar"); - ASSERT_EQ(errc::success, Status.getError()); - 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"); - Status = D->status("/baz"); - ASSERT_EQ(errc::success, Status.getError()); - 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 Status2 = D->status("/foo"); - ASSERT_EQ(errc::success, Status2.getError()); - EXPECT_FALSE(Status->equivalent(*Status2)); -} - -TEST(VirtualFileSystemTest, baseOnlyOverlay) { - IntrusiveRefCntPtr D(new DummyFileSystem()); - ErrorOr Status((error_code())); - EXPECT_FALSE(Status = D->status("/foo")); - - IntrusiveRefCntPtr O(new vfs::OverlayFileSystem(D)); - EXPECT_FALSE(Status = O->status("/foo")); - - D->addRegularFile("/foo"); - Status = D->status("/foo"); - EXPECT_EQ(errc::success, Status.getError()); - - ErrorOr Status2((error_code())); - Status2 = O->status("/foo"); - EXPECT_EQ(errc::success, Status2.getError()); - EXPECT_TRUE(Status->equivalent(*Status2)); -} - -TEST(VirtualFileSystemTest, overlayFiles) { - IntrusiveRefCntPtr Base(new DummyFileSystem()); - IntrusiveRefCntPtr Middle(new DummyFileSystem()); - IntrusiveRefCntPtr Top(new DummyFileSystem()); - IntrusiveRefCntPtr O(new vfs::OverlayFileSystem(Base)); - O->pushOverlay(Middle); - O->pushOverlay(Top); - - ErrorOr Status1((error_code())), Status2((error_code())), - Status3((error_code())), StatusB((error_code())), - StatusM((error_code())), StatusT((error_code())); - - Base->addRegularFile("/foo"); - StatusB = Base->status("/foo"); - ASSERT_EQ(errc::success, StatusB.getError()); - Status1 = O->status("/foo"); - ASSERT_EQ(errc::success, Status1.getError()); - Middle->addRegularFile("/foo"); - StatusM = Middle->status("/foo"); - ASSERT_EQ(errc::success, StatusM.getError()); - Status2 = O->status("/foo"); - ASSERT_EQ(errc::success, Status2.getError()); - Top->addRegularFile("/foo"); - StatusT = Top->status("/foo"); - ASSERT_EQ(errc::success, StatusT.getError()); - Status3 = O->status("/foo"); - ASSERT_EQ(errc::success, Status3.getError()); - - 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, overlayDirsNonMerged) { - IntrusiveRefCntPtr Lower(new DummyFileSystem()); - IntrusiveRefCntPtr Upper(new DummyFileSystem()); - IntrusiveRefCntPtr - O(new vfs::OverlayFileSystem(Lower)); - O->pushOverlay(Upper); - - Lower->addDirectory("/lower-only"); - Upper->addDirectory("/upper-only"); - - // non-merged paths should be the same - ErrorOr Status1 = Lower->status("/lower-only"); - ASSERT_EQ(errc::success, Status1.getError()); - ErrorOr Status2 = O->status("/lower-only"); - ASSERT_EQ(errc::success, Status2.getError()); - EXPECT_TRUE(Status1->equivalent(*Status2)); - - Status1 = Upper->status("/upper-only"); - ASSERT_EQ(errc::success, Status1.getError()); - Status2 = O->status("/upper-only"); - ASSERT_EQ(errc::success, Status2.getError()); - EXPECT_TRUE(Status1->equivalent(*Status2)); -} - -TEST(VirtualFileSystemTest, mergedDirPermissions) { - // merged directories get the permissions of the upper dir - IntrusiveRefCntPtr Lower(new DummyFileSystem()); - IntrusiveRefCntPtr Upper(new DummyFileSystem()); - IntrusiveRefCntPtr - O(new vfs::OverlayFileSystem(Lower)); - O->pushOverlay(Upper); - - ErrorOr Status((error_code())); - Lower->addDirectory("/both", sys::fs::owner_read); - Upper->addDirectory("/both", sys::fs::owner_all | sys::fs::group_read); - Status = O->status("/both"); - ASSERT_EQ(errc::success, Status.getError()); - 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); - Status = O->status("/both/foo"); - ASSERT_EQ(errc::success, Status.getError()); - EXPECT_EQ(0400, Status->getPermissions()); - Status = O->status("/both/bar"); - ASSERT_EQ(errc::success, Status.getError()); - EXPECT_EQ(0200, Status->getPermissions()); -} -- 2.40.0