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