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
Instance()45 FileSystem &FileSystem::Instance() { return *InstanceImpl(); }
46
Initialize()47 void FileSystem::Initialize() {
48 lldbassert(!InstanceImpl() && "Already initialized.");
49 InstanceImpl().emplace();
50 }
51
Initialize(std::shared_ptr<FileCollector> collector)52 void FileSystem::Initialize(std::shared_ptr<FileCollector> collector) {
53 lldbassert(!InstanceImpl() && "Already initialized.");
54 InstanceImpl().emplace(collector);
55 }
56
Initialize(const FileSpec & mapping)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
Initialize(IntrusiveRefCntPtr<vfs::FileSystem> fs)73 void FileSystem::Initialize(IntrusiveRefCntPtr<vfs::FileSystem> fs) {
74 lldbassert(!InstanceImpl() && "Already initialized.");
75 InstanceImpl().emplace(fs);
76 }
77
Terminate()78 void FileSystem::Terminate() {
79 lldbassert(InstanceImpl() && "Already terminated.");
80 InstanceImpl().reset();
81 }
82
InstanceImpl()83 Optional<FileSystem> &FileSystem::InstanceImpl() {
84 static Optional<FileSystem> g_fs;
85 return g_fs;
86 }
87
DirBegin(const FileSpec & file_spec,std::error_code & ec)88 vfs::directory_iterator FileSystem::DirBegin(const FileSpec &file_spec,
89 std::error_code &ec) {
90 return DirBegin(file_spec.GetPath(), ec);
91 }
92
DirBegin(const Twine & dir,std::error_code & ec)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>
GetStatus(const FileSpec & file_spec) const99 FileSystem::GetStatus(const FileSpec &file_spec) const {
100 return GetStatus(file_spec.GetPath());
101 }
102
GetStatus(const Twine & path) const103 llvm::ErrorOr<vfs::Status> FileSystem::GetStatus(const Twine &path) const {
104 return m_fs->status(path);
105 }
106
107 sys::TimePoint<>
GetModificationTime(const FileSpec & file_spec) const108 FileSystem::GetModificationTime(const FileSpec &file_spec) const {
109 return GetModificationTime(file_spec.GetPath());
110 }
111
GetModificationTime(const Twine & path) const112 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
GetByteSize(const FileSpec & file_spec) const119 uint64_t FileSystem::GetByteSize(const FileSpec &file_spec) const {
120 return GetByteSize(file_spec.GetPath());
121 }
122
GetByteSize(const Twine & path) const123 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
GetPermissions(const FileSpec & file_spec) const130 uint32_t FileSystem::GetPermissions(const FileSpec &file_spec) const {
131 return GetPermissions(file_spec.GetPath());
132 }
133
GetPermissions(const FileSpec & file_spec,std::error_code & ec) const134 uint32_t FileSystem::GetPermissions(const FileSpec &file_spec,
135 std::error_code &ec) const {
136 return GetPermissions(file_spec.GetPath(), ec);
137 }
138
GetPermissions(const Twine & path) const139 uint32_t FileSystem::GetPermissions(const Twine &path) const {
140 std::error_code ec;
141 return GetPermissions(path, ec);
142 }
143
GetPermissions(const Twine & path,std::error_code & ec) const144 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
Exists(const Twine & path) const154 bool FileSystem::Exists(const Twine &path) const { return m_fs->exists(path); }
155
Exists(const FileSpec & file_spec) const156 bool FileSystem::Exists(const FileSpec &file_spec) const {
157 return Exists(file_spec.GetPath());
158 }
159
Readable(const Twine & path) const160 bool FileSystem::Readable(const Twine &path) const {
161 return GetPermissions(path) & sys::fs::perms::all_read;
162 }
163
Readable(const FileSpec & file_spec) const164 bool FileSystem::Readable(const FileSpec &file_spec) const {
165 return Readable(file_spec.GetPath());
166 }
167
IsDirectory(const Twine & path) const168 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
IsDirectory(const FileSpec & file_spec) const175 bool FileSystem::IsDirectory(const FileSpec &file_spec) const {
176 return IsDirectory(file_spec.GetPath());
177 }
178
IsLocal(const Twine & path) const179 bool FileSystem::IsLocal(const Twine &path) const {
180 bool b = false;
181 m_fs->isLocal(path, b);
182 return b;
183 }
184
IsLocal(const FileSpec & file_spec) const185 bool FileSystem::IsLocal(const FileSpec &file_spec) const {
186 return IsLocal(file_spec.GetPath());
187 }
188
EnumerateDirectory(Twine path,bool find_directories,bool find_files,bool find_other,EnumerateDirectoryCallbackType callback,void * callback_baton)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
MakeAbsolute(SmallVectorImpl<char> & path) const219 std::error_code FileSystem::MakeAbsolute(SmallVectorImpl<char> &path) const {
220 return m_fs->makeAbsolute(path);
221 }
222
MakeAbsolute(FileSpec & file_spec) const223 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
GetRealPath(const Twine & path,SmallVectorImpl<char> & output) const236 std::error_code FileSystem::GetRealPath(const Twine &path,
237 SmallVectorImpl<char> &output) const {
238 return m_fs->getRealPath(path, output);
239 }
240
Resolve(SmallVectorImpl<char> & path)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
Resolve(FileSpec & file_spec)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>
CreateDataBuffer(const llvm::Twine & path,uint64_t size,uint64_t offset)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>
CreateDataBuffer(const FileSpec & file_spec,uint64_t size,uint64_t offset)309 FileSystem::CreateDataBuffer(const FileSpec &file_spec, uint64_t size,
310 uint64_t offset) {
311 return CreateDataBuffer(file_spec.GetPath(), size, offset);
312 }
313
ResolveExecutableLocation(FileSpec & file_spec)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
OpenWithFS(const FileSystem & fs,const char * path,int flags,int mode)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
GetOpenFlags(uint32_t options)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
GetOpenMode(uint32_t permissions)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
Open(const FileSpec & file_spec,File::OpenOptions options,uint32_t permissions,bool should_close_fd)418 Expected<FileUP> FileSystem::Open(const FileSpec &file_spec,
419 File::OpenOptions options,
420 uint32_t permissions, bool should_close_fd) {
421 if (m_collector)
422 m_collector->addFile(file_spec.GetPath());
423
424 const int open_flags = GetOpenFlags(options);
425 const mode_t open_mode =
426 (open_flags & O_CREAT) ? GetOpenMode(permissions) : 0;
427
428 auto path = GetExternalPath(file_spec);
429 if (!path)
430 return errorCodeToError(path.getError());
431
432 int descriptor = llvm::sys::RetryAfterSignal(
433 -1, OpenWithFS, *this, path->c_str(), open_flags, open_mode);
434
435 if (!File::DescriptorIsValid(descriptor))
436 return llvm::errorCodeToError(
437 std::error_code(errno, std::system_category()));
438
439 auto file = std::unique_ptr<File>(
440 new NativeFile(descriptor, options, should_close_fd));
441 assert(file->IsValid());
442 return std::move(file);
443 }
444
GetExternalPath(const llvm::Twine & path)445 ErrorOr<std::string> FileSystem::GetExternalPath(const llvm::Twine &path) {
446 if (!m_mapped)
447 return path.str();
448
449 // If VFS mapped we know the underlying FS is a RedirectingFileSystem.
450 ErrorOr<vfs::RedirectingFileSystem::Entry *> E =
451 static_cast<vfs::RedirectingFileSystem &>(*m_fs).lookupPath(path);
452 if (!E) {
453 if (E.getError() == llvm::errc::no_such_file_or_directory) {
454 return path.str();
455 }
456 return E.getError();
457 }
458
459 auto *F = dyn_cast<vfs::RedirectingFileSystem::RedirectingFileEntry>(*E);
460 if (!F)
461 return make_error_code(llvm::errc::not_supported);
462
463 return F->getExternalContentsPath().str();
464 }
465
GetExternalPath(const FileSpec & file_spec)466 ErrorOr<std::string> FileSystem::GetExternalPath(const FileSpec &file_spec) {
467 return GetExternalPath(file_spec.GetPath());
468 }
469