contrib/llvm-project/lldb/source/Host/common/FileSystem.cpp

   1 //===-- FileSystem.cpp ------------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Host/FileSystem.h"
  10
  11 #include "lldb/Utility/LLDBAssert.h"
  12 #include "lldb/Utility/TildeExpressionResolver.h"
  13
  14 #include "llvm/Support/Errc.h"
  15 #include "llvm/Support/Errno.h"
  16 #include "llvm/Support/Error.h"
  17 #include "llvm/Support/FileSystem.h"
  18 #include "llvm/Support/Path.h"
  19 #include "llvm/Support/Program.h"
  20 #include "llvm/Support/Threading.h"
  21
  22 #include <errno.h>
  23 #include <fcntl.h>
  24 #include <limits.h>
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27
  28 #ifdef _WIN32
  29 #include "lldb/Host/windows/windows.h"
  30 #else
  31 #include <sys/ioctl.h>
  32 #include <sys/stat.h>
  33 #include <termios.h>
  34 #include <unistd.h>
  35 #endif
  36
  37 #include <algorithm>
  38 #include <fstream>
  39 #include <vector>
  40
  41 using namespace lldb;
  42 using namespace lldb_private;
  43 using namespace llvm;
  44
  45 FileSystem &FileSystem::Instance() { return *InstanceImpl(); }
  46
  47 void FileSystem::Initialize() {
  48   lldbassert(!InstanceImpl() && "Already initialized.");
  49   InstanceImpl().emplace();
  50 }
  51
  52 void FileSystem::Initialize(FileCollector &collector) {
  53   lldbassert(!InstanceImpl() && "Already initialized.");
  54   InstanceImpl().emplace(collector);
  55 }
  56
  57 llvm::Error FileSystem::Initialize(const FileSpec &mapping) {
  58   lldbassert(!InstanceImpl() && "Already initialized.");
  59
  60   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> buffer =
  61       llvm::vfs::getRealFileSystem()->getBufferForFile(mapping.GetPath());
  62
  63   if (!buffer)
  64     return llvm::errorCodeToError(buffer.getError());
  65
  66   InstanceImpl().emplace(llvm::vfs::getVFSFromYAML(std::move(buffer.get()),
  67                                                    nullptr, mapping.GetPath()),
  68                          true);
  69
  70   return llvm::Error::success();
  71 }
  72
  73 void FileSystem::Initialize(IntrusiveRefCntPtr<vfs::FileSystem> fs) {
  74   lldbassert(!InstanceImpl() && "Already initialized.");
  75   InstanceImpl().emplace(fs);
  76 }
  77
  78 void FileSystem::Terminate() {
  79   lldbassert(InstanceImpl() && "Already terminated.");
  80   InstanceImpl().reset();
  81 }
  82
  83 Optional<FileSystem> &FileSystem::InstanceImpl() {
  84   static Optional<FileSystem> g_fs;
  85   return g_fs;
  86 }
  87
  88 vfs::directory_iterator FileSystem::DirBegin(const FileSpec &file_spec,
  89                                              std::error_code &ec) {
  90   return DirBegin(file_spec.GetPath(), ec);
  91 }
  92
  93 vfs::directory_iterator FileSystem::DirBegin(const Twine &dir,
  94                                              std::error_code &ec) {
  95   return m_fs->dir_begin(dir, ec);
  96 }
  97
  98 llvm::ErrorOr<vfs::Status>
  99 FileSystem::GetStatus(const FileSpec &file_spec) const {
 100   return GetStatus(file_spec.GetPath());
 101 }
 102
 103 llvm::ErrorOr<vfs::Status> FileSystem::GetStatus(const Twine &path) const {
 104   return m_fs->status(path);
 105 }
 106
 107 sys::TimePoint<>
 108 FileSystem::GetModificationTime(const FileSpec &file_spec) const {
 109   return GetModificationTime(file_spec.GetPath());
 110 }
 111
 112 sys::TimePoint<> FileSystem::GetModificationTime(const Twine &path) const {
 113   ErrorOr<vfs::Status> status = m_fs->status(path);
 114   if (!status)
 115     return sys::TimePoint<>();
 116   return status->getLastModificationTime();
 117 }
 118
 119 uint64_t FileSystem::GetByteSize(const FileSpec &file_spec) const {
 120   return GetByteSize(file_spec.GetPath());
 121 }
 122
 123 uint64_t FileSystem::GetByteSize(const Twine &path) const {
 124   ErrorOr<vfs::Status> status = m_fs->status(path);
 125   if (!status)
 126     return 0;
 127   return status->getSize();
 128 }
 129
 130 uint32_t FileSystem::GetPermissions(const FileSpec &file_spec) const {
 131   return GetPermissions(file_spec.GetPath());
 132 }
 133
 134 uint32_t FileSystem::GetPermissions(const FileSpec &file_spec,
 135                                     std::error_code &ec) const {
 136   return GetPermissions(file_spec.GetPath(), ec);
 137 }
 138
 139 uint32_t FileSystem::GetPermissions(const Twine &path) const {
 140   std::error_code ec;
 141   return GetPermissions(path, ec);
 142 }
 143
 144 uint32_t FileSystem::GetPermissions(const Twine &path,
 145                                     std::error_code &ec) const {
 146   ErrorOr<vfs::Status> status = m_fs->status(path);
 147   if (!status) {
 148     ec = status.getError();
 149     return sys::fs::perms::perms_not_known;
 150   }
 151   return status->getPermissions();
 152 }
 153
 154 bool FileSystem::Exists(const Twine &path) const { return m_fs->exists(path); }
 155
 156 bool FileSystem::Exists(const FileSpec &file_spec) const {
 157   return Exists(file_spec.GetPath());
 158 }
 159
 160 bool FileSystem::Readable(const Twine &path) const {
 161   return GetPermissions(path) & sys::fs::perms::all_read;
 162 }
 163
 164 bool FileSystem::Readable(const FileSpec &file_spec) const {
 165   return Readable(file_spec.GetPath());
 166 }
 167
 168 bool FileSystem::IsDirectory(const Twine &path) const {
 169   ErrorOr<vfs::Status> status = m_fs->status(path);
 170   if (!status)
 171     return false;
 172   return status->isDirectory();
 173 }
 174
 175 bool FileSystem::IsDirectory(const FileSpec &file_spec) const {
 176   return IsDirectory(file_spec.GetPath());
 177 }
 178
 179 bool FileSystem::IsLocal(const Twine &path) const {
 180   bool b = false;
 181   m_fs->isLocal(path, b);
 182   return b;
 183 }
 184
 185 bool FileSystem::IsLocal(const FileSpec &file_spec) const {
 186   return IsLocal(file_spec.GetPath());
 187 }
 188
 189 void FileSystem::EnumerateDirectory(Twine path, bool find_directories,
 190                                     bool find_files, bool find_other,
 191                                     EnumerateDirectoryCallbackType callback,
 192                                     void *callback_baton) {
 193   std::error_code EC;
 194   vfs::recursive_directory_iterator Iter(*m_fs, path, EC);
 195   vfs::recursive_directory_iterator End;
 196   for (; Iter != End && !EC; Iter.increment(EC)) {
 197     const auto &Item = *Iter;
 198     ErrorOr<vfs::Status> Status = m_fs->status(Item.path());
 199     if (!Status)
 200       break;
 201     if (!find_files && Status->isRegularFile())
 202       continue;
 203     if (!find_directories && Status->isDirectory())
 204       continue;
 205     if (!find_other && Status->isOther())
 206       continue;
 207
 208     auto Result = callback(callback_baton, Status->getType(), Item.path());
 209     if (Result == eEnumerateDirectoryResultQuit)
 210       return;
 211     if (Result == eEnumerateDirectoryResultNext) {
 212       // Default behavior is to recurse. Opt out if the callback doesn't want
 213       // this behavior.
 214       Iter.no_push();
 215     }
 216   }
 217 }
 218
 219 std::error_code FileSystem::MakeAbsolute(SmallVectorImpl<char> &path) const {
 220   return m_fs->makeAbsolute(path);
 221 }
 222
 223 std::error_code FileSystem::MakeAbsolute(FileSpec &file_spec) const {
 224   SmallString<128> path;
 225   file_spec.GetPath(path, false);
 226
 227   auto EC = MakeAbsolute(path);
 228   if (EC)
 229     return EC;
 230
 231   FileSpec new_file_spec(path, file_spec.GetPathStyle());
 232   file_spec = new_file_spec;
 233   return {};
 234 }
 235
 236 std::error_code FileSystem::GetRealPath(const Twine &path,
 237                                         SmallVectorImpl<char> &output) const {
 238   return m_fs->getRealPath(path, output);
 239 }
 240
 241 void FileSystem::Resolve(SmallVectorImpl<char> &path) {
 242   if (path.empty())
 243     return;
 244
 245   // Resolve tilde in path.
 246   SmallString<128> resolved(path.begin(), path.end());
 247   StandardTildeExpressionResolver Resolver;
 248   Resolver.ResolveFullPath(llvm::StringRef(path.begin(), path.size()),
 249                            resolved);
 250
 251   // Try making the path absolute if it exists.
 252   SmallString<128> absolute(resolved.begin(), resolved.end());
 253   MakeAbsolute(absolute);
 254
 255   path.clear();
 256   if (Exists(absolute)) {
 257     path.append(absolute.begin(), absolute.end());
 258   } else {
 259     path.append(resolved.begin(), resolved.end());
 260   }
 261 }
 262
 263 void FileSystem::Resolve(FileSpec &file_spec) {
 264   // Extract path from the FileSpec.
 265   SmallString<128> path;
 266   file_spec.GetPath(path);
 267
 268   // Resolve the path.
 269   Resolve(path);
 270
 271   // Update the FileSpec with the resolved path.
 272   if (file_spec.GetFilename().IsEmpty())
 273     file_spec.GetDirectory().SetString(path);
 274   else
 275     file_spec.SetPath(path);
 276   file_spec.SetIsResolved(true);
 277 }
 278
 279 std::shared_ptr<DataBufferLLVM>
 280 FileSystem::CreateDataBuffer(const llvm::Twine &path, uint64_t size,
 281                              uint64_t offset) {
 282   if (m_collector)
 283     m_collector->AddFile(path);
 284
 285   const bool is_volatile = !IsLocal(path);
 286   const ErrorOr<std::string> external_path = GetExternalPath(path);
 287
 288   if (!external_path)
 289     return nullptr;
 290
 291   std::unique_ptr<llvm::WritableMemoryBuffer> buffer;
 292   if (size == 0) {
 293     auto buffer_or_error =
 294         llvm::WritableMemoryBuffer::getFile(*external_path, -1, is_volatile);
 295     if (!buffer_or_error)
 296       return nullptr;
 297     buffer = std::move(*buffer_or_error);
 298   } else {
 299     auto buffer_or_error = llvm::WritableMemoryBuffer::getFileSlice(
 300         *external_path, size, offset, is_volatile);
 301     if (!buffer_or_error)
 302       return nullptr;
 303     buffer = std::move(*buffer_or_error);
 304   }
 305   return std::shared_ptr<DataBufferLLVM>(new DataBufferLLVM(std::move(buffer)));
 306 }
 307
 308 std::shared_ptr<DataBufferLLVM>
 309 FileSystem::CreateDataBuffer(const FileSpec &file_spec, uint64_t size,
 310                              uint64_t offset) {
 311   return CreateDataBuffer(file_spec.GetPath(), size, offset);
 312 }
 313
 314 bool FileSystem::ResolveExecutableLocation(FileSpec &file_spec) {
 315   // If the directory is set there's nothing to do.
 316   ConstString directory = file_spec.GetDirectory();
 317   if (directory)
 318     return false;
 319
 320   // We cannot look for a file if there's no file name.
 321   ConstString filename = file_spec.GetFilename();
 322   if (!filename)
 323     return false;
 324
 325   // Search for the file on the host.
 326   const std::string filename_str(filename.GetCString());
 327   llvm::ErrorOr<std::string> error_or_path =
 328       llvm::sys::findProgramByName(filename_str);
 329   if (!error_or_path)
 330     return false;
 331
 332   // findProgramByName returns "." if it can't find the file.
 333   llvm::StringRef path = *error_or_path;
 334   llvm::StringRef parent = llvm::sys::path::parent_path(path);
 335   if (parent.empty() || parent == ".")
 336     return false;
 337
 338   // Make sure that the result exists.
 339   FileSpec result(*error_or_path);
 340   if (!Exists(result))
 341     return false;
 342
 343   file_spec = result;
 344   return true;
 345 }
 346
 347 static int OpenWithFS(const FileSystem &fs, const char *path, int flags,
 348                       int mode) {
 349   return const_cast<FileSystem &>(fs).Open(path, flags, mode);
 350 }
 351
 352 static int GetOpenFlags(uint32_t options) {
 353   const bool read = options & File::eOpenOptionRead;
 354   const bool write = options & File::eOpenOptionWrite;
 355
 356   int open_flags = 0;
 357   if (write) {
 358     if (read)
 359       open_flags |= O_RDWR;
 360     else
 361       open_flags |= O_WRONLY;
 362
 363     if (options & File::eOpenOptionAppend)
 364       open_flags |= O_APPEND;
 365
 366     if (options & File::eOpenOptionTruncate)
 367       open_flags |= O_TRUNC;
 368
 369     if (options & File::eOpenOptionCanCreate)
 370       open_flags |= O_CREAT;
 371
 372     if (options & File::eOpenOptionCanCreateNewOnly)
 373       open_flags |= O_CREAT | O_EXCL;
 374   } else if (read) {
 375     open_flags |= O_RDONLY;
 376
 377 #ifndef _WIN32
 378     if (options & File::eOpenOptionDontFollowSymlinks)
 379       open_flags |= O_NOFOLLOW;
 380 #endif
 381   }
 382
 383 #ifndef _WIN32
 384   if (options & File::eOpenOptionNonBlocking)
 385     open_flags |= O_NONBLOCK;
 386   if (options & File::eOpenOptionCloseOnExec)
 387     open_flags |= O_CLOEXEC;
 388 #else
 389   open_flags |= O_BINARY;
 390 #endif
 391
 392   return open_flags;
 393 }
 394
 395 static mode_t GetOpenMode(uint32_t permissions) {
 396   mode_t mode = 0;
 397   if (permissions & lldb::eFilePermissionsUserRead)
 398     mode |= S_IRUSR;
 399   if (permissions & lldb::eFilePermissionsUserWrite)
 400     mode |= S_IWUSR;
 401   if (permissions & lldb::eFilePermissionsUserExecute)
 402     mode |= S_IXUSR;
 403   if (permissions & lldb::eFilePermissionsGroupRead)
 404     mode |= S_IRGRP;
 405   if (permissions & lldb::eFilePermissionsGroupWrite)
 406     mode |= S_IWGRP;
 407   if (permissions & lldb::eFilePermissionsGroupExecute)
 408     mode |= S_IXGRP;
 409   if (permissions & lldb::eFilePermissionsWorldRead)
 410     mode |= S_IROTH;
 411   if (permissions & lldb::eFilePermissionsWorldWrite)
 412     mode |= S_IWOTH;
 413   if (permissions & lldb::eFilePermissionsWorldExecute)
 414     mode |= S_IXOTH;
 415   return mode;
 416 }
 417
 418 Status FileSystem::Open(File &File, const FileSpec &file_spec, uint32_t options,
 419                         uint32_t permissions, bool should_close_fd) {
 420   if (m_collector)
 421     m_collector->AddFile(file_spec);
 422
 423   if (File.IsValid())
 424     File.Close();
 425
 426   const int open_flags = GetOpenFlags(options);
 427   const mode_t open_mode =
 428       (open_flags & O_CREAT) ? GetOpenMode(permissions) : 0;
 429
 430   auto path = GetExternalPath(file_spec);
 431   if (!path)
 432     return Status(path.getError());
 433
 434   int descriptor = llvm::sys::RetryAfterSignal(
 435       -1, OpenWithFS, *this, path->c_str(), open_flags, open_mode);
 436
 437   Status error;
 438   if (!File::DescriptorIsValid(descriptor)) {
 439     File.SetDescriptor(descriptor, false);
 440     error.SetErrorToErrno();
 441   } else {
 442     File.SetDescriptor(descriptor, should_close_fd);
 443     File.SetOptions(options);
 444   }
 445   return error;
 446 }
 447
 448 ErrorOr<std::string> FileSystem::GetExternalPath(const llvm::Twine &path) {
 449   if (!m_mapped)
 450     return path.str();
 451
 452   // If VFS mapped we know the underlying FS is a RedirectingFileSystem.
 453   ErrorOr<vfs::RedirectingFileSystem::Entry *> E =
 454       static_cast<vfs::RedirectingFileSystem &>(*m_fs).lookupPath(path);
 455   if (!E) {
 456     if (E.getError() == llvm::errc::no_such_file_or_directory) {
 457       return path.str();
 458     }
 459     return E.getError();
 460   }
 461
 462   auto *F = dyn_cast<vfs::RedirectingFileSystem::RedirectingFileEntry>(*E);
 463   if (!F)
 464     return make_error_code(llvm::errc::not_supported);
 465
 466   return F->getExternalContentsPath().str();
 467 }
 468
 469 ErrorOr<std::string> FileSystem::GetExternalPath(const FileSpec &file_spec) {
 470   return GetExternalPath(file_spec.GetPath());
 471 }