Revert "[VFS] Allow multiple RealFileSystem instances with independent CWDs."

This reverts commit r351079, r351069 and r351050 as it broken the greendragon bots on macOS.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@351091 91177308-0d34-0410-b5e6-96231b3b80d8

lib/Support/VirtualFileSystem.cpp

@@ -228,28 +228,9 @@ std::error_code RealFile::close() {
 
 namespace {
 
-/// A file system according to your operating system.
-/// This may be linked to the process's working directory, or maintain its own.
-///
-/// Currently, its own working directory is emulated by storing the path and
-/// sending absolute paths to llvm::sys::fs:: functions.
-/// A more principled approach would be to push this down a level, modelling
-/// the working dir as an llvm::sys::fs::WorkingDir or similar.
-/// This would enable the use of openat()-style functions on some platforms.
+/// The file system according to your operating system.
 class RealFileSystem : public FileSystem {
 public:
-  explicit RealFileSystem(bool LinkCWDToProcess) {
-    if (!LinkCWDToProcess) {
-      SmallString<128> PWD, RealPWD;
-      if (llvm::sys::fs::current_path(PWD))
-        return; // Awful, but nothing to do here.
-      if (llvm::sys::fs::real_path(PWD, RealPWD))
-        WD = {PWD, PWD};
-      else
-        WD = {PWD, RealPWD};
-    }
-  }
-
   ErrorOr<Status> status(const Twine &Path) override;
   ErrorOr<std::unique_ptr<File>> openFileForRead(const Twine &Path) override;
   directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override;
@@ -261,32 +242,15 @@ public:
                               SmallVectorImpl<char> &Output) const override;
 
 private:
-  // If this FS has its own working dir, use it to make Path absolute.
-  // The returned twine is safe to use as long as both Storage and Path live.
-  Twine adjustPath(const Twine &Path, SmallVectorImpl<char> &Storage) const {
-    if (!WD)
-      return Path;
-    Path.toVector(Storage);
-    sys::fs::make_absolute(WD->Resolved, Storage);
-    return Storage;
-  }
-
-  struct WorkingDirectory {
-    // The current working directory, without symlinks resolved. (echo $PWD).
-    SmallString<128> Specified;
-    // The current working directory, with links resolved. (readlink .).
-    SmallString<128> Resolved;
-  };
-  Optional<WorkingDirectory> WD;
+  mutable std::mutex CWDMutex;
+  mutable std::string CWDCache;
 };
 
 } // namespace
 
 ErrorOr<Status> RealFileSystem::status(const Twine &Path) {
-  SmallString<256> Storage;
   sys::fs::file_status RealStatus;
-  if (std::error_code EC =
-          sys::fs::status(adjustPath(Path, Storage), RealStatus))
+  if (std::error_code EC = sys::fs::status(Path, RealStatus))
     return EC;
   return Status::copyWithNewName(RealStatus, Path.str());
 }
@@ -294,61 +258,56 @@ ErrorOr<Status> RealFileSystem::status(const Twine &Path) {
 ErrorOr<std::unique_ptr<File>>
 RealFileSystem::openFileForRead(const Twine &Name) {
   int FD;
-  SmallString<256> RealName, Storage;
-  if (std::error_code EC = sys::fs::openFileForRead(
-          adjustPath(Name, Storage), FD, sys::fs::OF_None, &RealName))
+  SmallString<256> RealName;
+  if (std::error_code EC =
+          sys::fs::openFileForRead(Name, FD, sys::fs::OF_None, &RealName))
     return EC;
   return std::unique_ptr<File>(new RealFile(FD, Name.str(), RealName.str()));
 }
 
 llvm::ErrorOr<std::string> RealFileSystem::getCurrentWorkingDirectory() const {
-  if (WD)
-    return WD->Specified.str();
-
-  SmallString<128> Dir;
+  std::lock_guard<std::mutex> Lock(CWDMutex);
+  if (!CWDCache.empty())
+    return CWDCache;
+  SmallString<256> Dir;
   if (std::error_code EC = llvm::sys::fs::current_path(Dir))
     return EC;
-  return Dir.str();
+  CWDCache = Dir.str();
+  return CWDCache;
 }
 
 std::error_code RealFileSystem::setCurrentWorkingDirectory(const Twine &Path) {
-  if (!WD)
-    return llvm::sys::fs::set_current_path(Path);
+  // FIXME: chdir is thread hostile; on the other hand, creating the same
+  // behavior as chdir is complex: chdir resolves the path once, thus
+  // guaranteeing that all subsequent relative path operations work
+  // on the same path the original chdir resulted in. This makes a
+  // difference for example on network filesystems, where symlinks might be
+  // switched during runtime of the tool. Fixing this depends on having a
+  // file system abstraction that allows openat() style interactions.
+  if (auto EC = llvm::sys::fs::set_current_path(Path))
+    return EC;
 
-  SmallString<128> Absolute, Resolved, Storage;
-  adjustPath(Path, Storage).toVector(Absolute);
-  bool IsDir;
-  if (auto Err = llvm::sys::fs::is_directory(Absolute, IsDir))
-    return Err;
-  if (!IsDir)
-    return std::make_error_code(std::errc::not_a_directory);
-  if (auto Err = llvm::sys::fs::real_path(Absolute, Resolved))
-    return Err;
-  WD = {Absolute, Resolved};
+  // Invalidate cache.
+  std::lock_guard<std::mutex> Lock(CWDMutex);
+  CWDCache.clear();
   return std::error_code();
 }
 
 std::error_code RealFileSystem::isLocal(const Twine &Path, bool &Result) {
-  SmallString<256> Storage;
-  return llvm::sys::fs::is_local(adjustPath(Path, Storage), Result);
+  return llvm::sys::fs::is_local(Path, Result);
 }
 
 std::error_code
 RealFileSystem::getRealPath(const Twine &Path,
                             SmallVectorImpl<char> &Output) const {
-  SmallString<256> Storage;
-  return llvm::sys::fs::real_path(adjustPath(Path, Storage), Output);
+  return llvm::sys::fs::real_path(Path, Output);
 }
 
 IntrusiveRefCntPtr<FileSystem> vfs::getRealFileSystem() {
-  static IntrusiveRefCntPtr<FileSystem> FS(new RealFileSystem(true));
+  static IntrusiveRefCntPtr<FileSystem> FS = new RealFileSystem();
   return FS;
 }
 
-std::unique_ptr<FileSystem> vfs::createPhysicalFileSystem() {
-  return llvm::make_unique<RealFileSystem>(false);
-}
-
 namespace {
 
 class RealFSDirIter : public llvm::vfs::detail::DirIterImpl {
@@ -374,9 +333,7 @@ public:
 
 directory_iterator RealFileSystem::dir_begin(const Twine &Dir,
                                              std::error_code &EC) {
-  SmallString<128> Storage;
-  return directory_iterator(
-      std::make_shared<RealFSDirIter>(adjustPath(Dir, Storage), EC));
+  return directory_iterator(std::make_shared<RealFSDirIter>(Dir, EC));
 }
 
 //===-----------------------------------------------------------------------===/