LLDB mainline
ModuleCache.cpp
Go to the documentation of this file.
1//===-- ModuleCache.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
10
11#include "lldb/Core/Module.h"
14#include "lldb/Host/File.h"
15#include "lldb/Host/LockFile.h"
17#include "lldb/Utility/Log.h"
18#include "llvm/Support/FileSystem.h"
19#include "llvm/Support/FileUtilities.h"
20
21#include <cassert>
22
23#include <cstdio>
24
25using namespace lldb;
26using namespace lldb_private;
27
28namespace {
29
30const char *kModulesSubdir = ".cache";
31const char *kLockDirName = ".lock";
32const char *kTempFileName = ".temp";
33const char *kTempSymFileName = ".symtemp";
34const char *kSymFileExtension = ".sym";
35const char *kFSIllegalChars = "\\/:*?\"<>|";
36
37std::string GetEscapedHostname(const char *hostname) {
38 if (hostname == nullptr)
39 hostname = "unknown";
40 std::string result(hostname);
41 size_t size = result.size();
42 for (size_t i = 0; i < size; ++i) {
43 if ((result[i] >= 1 && result[i] <= 31) ||
44 strchr(kFSIllegalChars, result[i]) != nullptr)
45 result[i] = '_';
46 }
47 return result;
48}
49
50class ModuleLock {
51private:
52 FileUP m_file_up;
53 std::unique_ptr<lldb_private::LockFile> m_lock;
54 FileSpec m_file_spec;
55
56public:
57 ModuleLock(const FileSpec &root_dir_spec, const UUID &uuid, Status &error);
58 void Delete();
59};
60
61static FileSpec JoinPath(const FileSpec &path1, const char *path2) {
62 FileSpec result_spec(path1);
63 result_spec.AppendPathComponent(path2);
64 return result_spec;
65}
66
67static Status MakeDirectory(const FileSpec &dir_path) {
68 namespace fs = llvm::sys::fs;
69
70 return fs::create_directories(dir_path.GetPath(), true, fs::perms::owner_all);
71}
72
73FileSpec GetModuleDirectory(const FileSpec &root_dir_spec, const UUID &uuid) {
74 const auto modules_dir_spec = JoinPath(root_dir_spec, kModulesSubdir);
75 return JoinPath(modules_dir_spec, uuid.GetAsString().c_str());
76}
77
78FileSpec GetSymbolFileSpec(const FileSpec &module_file_spec) {
79 return FileSpec(module_file_spec.GetPath() + kSymFileExtension);
80}
81
82void DeleteExistingModule(const FileSpec &root_dir_spec,
83 const FileSpec &sysroot_module_path_spec) {
84 Log *log = GetLog(LLDBLog::Modules);
85 UUID module_uuid;
86 {
87 auto module_sp =
88 std::make_shared<Module>(ModuleSpec(sysroot_module_path_spec));
89 module_uuid = module_sp->GetUUID();
90 }
91
92 if (!module_uuid.IsValid())
93 return;
94
96 ModuleLock lock(root_dir_spec, module_uuid, error);
97 if (error.Fail()) {
98 LLDB_LOGF(log, "Failed to lock module %s: %s",
99 module_uuid.GetAsString().c_str(), error.AsCString());
100 }
101
102 namespace fs = llvm::sys::fs;
103 fs::file_status st;
104 if (status(sysroot_module_path_spec.GetPath(), st))
105 return;
106
107 if (st.getLinkCount() > 2) // module is referred by other hosts.
108 return;
109
110 const auto module_spec_dir = GetModuleDirectory(root_dir_spec, module_uuid);
111 llvm::sys::fs::remove_directories(module_spec_dir.GetPath());
112 lock.Delete();
113}
114
115void DecrementRefExistingModule(const FileSpec &root_dir_spec,
116 const FileSpec &sysroot_module_path_spec) {
117 // Remove $platform/.cache/$uuid folder if nobody else references it.
118 DeleteExistingModule(root_dir_spec, sysroot_module_path_spec);
119
120 // Remove sysroot link.
121 llvm::sys::fs::remove(sysroot_module_path_spec.GetPath());
122
123 FileSpec symfile_spec = GetSymbolFileSpec(sysroot_module_path_spec);
124 llvm::sys::fs::remove(symfile_spec.GetPath());
125}
126
127Status CreateHostSysRootModuleLink(const FileSpec &root_dir_spec,
128 const char *hostname,
129 const FileSpec &platform_module_spec,
130 const FileSpec &local_module_spec,
131 bool delete_existing) {
132 const auto sysroot_module_path_spec =
133 JoinPath(JoinPath(root_dir_spec, hostname),
134 platform_module_spec.GetPath().c_str());
135 if (FileSystem::Instance().Exists(sysroot_module_path_spec)) {
136 if (!delete_existing)
137 return Status();
138
139 DecrementRefExistingModule(root_dir_spec, sysroot_module_path_spec);
140 }
141
142 Status error = MakeDirectory(
143 FileSpec(sysroot_module_path_spec.GetDirectory().AsCString()));
144 if (error.Fail())
145 return error;
146
147 return llvm::sys::fs::create_hard_link(local_module_spec.GetPath(),
148 sysroot_module_path_spec.GetPath());
149}
150
151} // namespace
152
153ModuleLock::ModuleLock(const FileSpec &root_dir_spec, const UUID &uuid,
154 Status &error) {
155 const auto lock_dir_spec = JoinPath(root_dir_spec, kLockDirName);
156 error = MakeDirectory(lock_dir_spec);
157 if (error.Fail())
158 return;
159
160 m_file_spec = JoinPath(lock_dir_spec, uuid.GetAsString().c_str());
161
162 auto file = FileSystem::Instance().Open(
165 if (file)
166 m_file_up = std::move(file.get());
167 else {
168 m_file_up.reset();
169 error = Status::FromError(file.takeError());
170 return;
171 }
172
173 m_lock = std::make_unique<lldb_private::LockFile>(m_file_up->GetDescriptor());
174 error = m_lock->WriteLock(0, 1);
175 if (error.Fail())
176 error =
177 Status::FromErrorStringWithFormatv("Failed to lock file: {0}", error);
178}
179
180void ModuleLock::Delete() {
181 if (!m_file_up)
182 return;
183
184 m_file_up->Close();
185 m_file_up.reset();
186 llvm::sys::fs::remove(m_file_spec.GetPath());
187}
188
189/////////////////////////////////////////////////////////////////////////
190
191Status ModuleCache::Put(const FileSpec &root_dir_spec, const char *hostname,
192 const ModuleSpec &module_spec, const FileSpec &tmp_file,
193 const FileSpec &target_file) {
194 const auto module_spec_dir =
195 GetModuleDirectory(root_dir_spec, module_spec.GetUUID());
196 const auto module_file_path =
197 JoinPath(module_spec_dir, target_file.GetFilename().AsCString());
198
199 const auto tmp_file_path = tmp_file.GetPath();
200 const auto err_code =
201 llvm::sys::fs::rename(tmp_file_path, module_file_path.GetPath());
202 if (err_code)
204 "Failed to rename file %s to %s: %s", tmp_file_path.c_str(),
205 module_file_path.GetPath().c_str(), err_code.message().c_str());
206
207 const auto error = CreateHostSysRootModuleLink(
208 root_dir_spec, hostname, target_file, module_file_path, true);
209 if (error.Fail())
210 return Status::FromErrorStringWithFormat("Failed to create link to %s: %s",
211 module_file_path.GetPath().c_str(),
212 error.AsCString());
213 return Status();
214}
215
216Status ModuleCache::Get(const FileSpec &root_dir_spec, const char *hostname,
217 const ModuleSpec &module_spec,
218 ModuleSP &cached_module_sp, bool *did_create_ptr) {
219 const auto find_it =
220 m_loaded_modules.find(module_spec.GetUUID().GetAsString());
221 if (find_it != m_loaded_modules.end()) {
222 cached_module_sp = (*find_it).second.lock();
223 if (cached_module_sp)
224 return Status();
225 m_loaded_modules.erase(find_it);
226 }
227
228 const auto module_spec_dir =
229 GetModuleDirectory(root_dir_spec, module_spec.GetUUID());
230 const auto module_file_path = JoinPath(
231 module_spec_dir, module_spec.GetFileSpec().GetFilename().AsCString());
232
233 if (!FileSystem::Instance().Exists(module_file_path))
235 "Module %s not found", module_file_path.GetPath().c_str());
236 if (FileSystem::Instance().GetByteSize(module_file_path) !=
237 module_spec.GetObjectSize())
239 "Module %s has invalid file size", module_file_path.GetPath().c_str());
240
241 // We may have already cached module but downloaded from an another host - in
242 // this case let's create a link to it.
243 auto error = CreateHostSysRootModuleLink(root_dir_spec, hostname,
244 module_spec.GetFileSpec(),
245 module_file_path, false);
246 if (error.Fail())
247 return Status::FromErrorStringWithFormat("Failed to create link to %s: %s",
248 module_file_path.GetPath().c_str(),
249 error.AsCString());
250
251 auto cached_module_spec(module_spec);
252 cached_module_spec.GetUUID().Clear(); // Clear UUID since it may contain md5
253 // content hash instead of real UUID.
254 cached_module_spec.GetFileSpec() = module_file_path;
255 cached_module_spec.GetPlatformFileSpec() = module_spec.GetFileSpec();
256
257 error = ModuleList::GetSharedModule(cached_module_spec, cached_module_sp,
258 nullptr, nullptr, did_create_ptr, false);
259 if (error.Fail())
260 return error;
261
262 FileSpec symfile_spec = GetSymbolFileSpec(cached_module_sp->GetFileSpec());
263 if (FileSystem::Instance().Exists(symfile_spec))
264 cached_module_sp->SetSymbolFileFileSpec(symfile_spec);
265
266 m_loaded_modules.insert(
267 std::make_pair(module_spec.GetUUID().GetAsString(), cached_module_sp));
268
269 return Status();
270}
271
273 const char *hostname,
274 const ModuleSpec &module_spec,
275 const ModuleDownloader &module_downloader,
276 const SymfileDownloader &symfile_downloader,
277 lldb::ModuleSP &cached_module_sp,
278 bool *did_create_ptr) {
279 const auto module_spec_dir =
280 GetModuleDirectory(root_dir_spec, module_spec.GetUUID());
281 auto error = MakeDirectory(module_spec_dir);
282 if (error.Fail())
283 return error;
284
285 ModuleLock lock(root_dir_spec, module_spec.GetUUID(), error);
286 if (error.Fail())
288 "Failed to lock module %s: %s",
289 module_spec.GetUUID().GetAsString().c_str(), error.AsCString());
290
291 const auto escaped_hostname(GetEscapedHostname(hostname));
292 // Check local cache for a module.
293 error = Get(root_dir_spec, escaped_hostname.c_str(), module_spec,
294 cached_module_sp, did_create_ptr);
295 if (error.Success())
296 return error;
297
298 const auto tmp_download_file_spec = JoinPath(module_spec_dir, kTempFileName);
299 error = module_downloader(module_spec, tmp_download_file_spec);
300 llvm::FileRemover tmp_file_remover(tmp_download_file_spec.GetPath());
301 if (error.Fail())
302 return Status::FromErrorStringWithFormat("Failed to download module: %s",
303 error.AsCString());
304
305 // Put downloaded file into local module cache.
306 error = Put(root_dir_spec, escaped_hostname.c_str(), module_spec,
307 tmp_download_file_spec, module_spec.GetFileSpec());
308 if (error.Fail())
310 "Failed to put module into cache: %s", error.AsCString());
311
312 tmp_file_remover.releaseFile();
313 error = Get(root_dir_spec, escaped_hostname.c_str(), module_spec,
314 cached_module_sp, did_create_ptr);
315 if (error.Fail())
316 return error;
317
318 // Fetching a symbol file for the module
319 const auto tmp_download_sym_file_spec =
320 JoinPath(module_spec_dir, kTempSymFileName);
321 error = symfile_downloader(cached_module_sp, tmp_download_sym_file_spec);
322 llvm::FileRemover tmp_symfile_remover(tmp_download_sym_file_spec.GetPath());
323 if (error.Fail())
324 // Failed to download a symfile but fetching the module was successful. The
325 // module might contain the necessary symbols and the debugging is also
326 // possible without a symfile.
327 return Status();
328
329 error = Put(root_dir_spec, escaped_hostname.c_str(), module_spec,
330 tmp_download_sym_file_spec,
331 GetSymbolFileSpec(module_spec.GetFileSpec()));
332 if (error.Fail())
334 "Failed to put symbol file into cache: %s", error.AsCString());
335
336 tmp_symfile_remover.releaseFile();
337
338 FileSpec symfile_spec = GetSymbolFileSpec(cached_module_sp->GetFileSpec());
339 cached_module_sp->SetSymbolFileFileSpec(symfile_spec);
340 return Status();
341}
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_LOGF(log,...)
Definition: Log.h:376
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:188
A file utility class.
Definition: FileSpec.h:56
const ConstString & GetFilename() const
Filename string const get accessor.
Definition: FileSpec.h:240
const ConstString & GetDirectory() const
Directory string const get accessor.
Definition: FileSpec.h:223
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:367
int Open(const char *path, int flags, int mode=0600)
Wraps ::open in a platform-independent way.
static FileSystem & Instance()
@ eOpenOptionWriteOnly
Definition: File.h:52
@ eOpenOptionCanCreate
Definition: File.h:56
@ eOpenOptionCloseOnExec
Definition: File.h:63
Status Get(const FileSpec &root_dir_spec, const char *hostname, const ModuleSpec &module_spec, lldb::ModuleSP &cached_module_sp, bool *did_create_ptr)
std::unordered_map< std::string, lldb::ModuleWP > m_loaded_modules
Definition: ModuleCache.h:69
std::function< Status(const lldb::ModuleSP &, const FileSpec &)> SymfileDownloader
Definition: ModuleCache.h:52
Status GetAndPut(const FileSpec &root_dir_spec, const char *hostname, const ModuleSpec &module_spec, const ModuleDownloader &module_downloader, const SymfileDownloader &symfile_downloader, lldb::ModuleSP &cached_module_sp, bool *did_create_ptr)
Status Put(const FileSpec &root_dir_spec, const char *hostname, const ModuleSpec &module_spec, const FileSpec &tmp_file, const FileSpec &target_file)
std::function< Status(const ModuleSpec &, const FileSpec &)> ModuleDownloader
Definition: ModuleCache.h:50
static Status GetSharedModule(const ModuleSpec &module_spec, lldb::ModuleSP &module_sp, const FileSpecList *module_search_paths_ptr, llvm::SmallVectorImpl< lldb::ModuleSP > *old_modules, bool *did_create_ptr, bool always_create=false)
Definition: ModuleList.cpp:789
FileSpec & GetFileSpec()
Definition: ModuleSpec.h:53
uint64_t GetObjectSize() const
Definition: ModuleSpec.h:113
An error handling class.
Definition: Status.h:118
static Status FromErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Definition: Status.cpp:106
static Status static Status FromErrorStringWithFormatv(const char *format, Args &&...args)
Definition: Status.h:151
static Status FromError(llvm::Error error)
Avoid using this in new code. Migrate APIs to llvm::Expected instead.
Definition: Status.cpp:137
std::string GetAsString(llvm::StringRef separator="-") const
Definition: UUID.cpp:49
bool IsValid() const
Definition: UUID.h:69
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:332
Definition: SBAddress.h:15
std::unique_ptr< lldb_private::File > FileUP
Definition: lldb-forward.h:352
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:373