LLDB  mainline
ModuleCache.cpp
Go to the documentation of this file.
1 //===--------------------- ModuleCache.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 
10 
11 #include "lldb/Core/Module.h"
12 #include "lldb/Core/ModuleList.h"
13 #include "lldb/Core/ModuleSpec.h"
14 #include "lldb/Host/File.h"
15 #include "lldb/Host/LockFile.h"
16 #include "lldb/Utility/Log.h"
17 #include "llvm/Support/FileSystem.h"
18 #include "llvm/Support/FileUtilities.h"
19 
20 #include <assert.h>
21 
22 #include <cstdio>
23 
24 using namespace lldb;
25 using namespace lldb_private;
26 
27 namespace {
28 
29 const char *kModulesSubdir = ".cache";
30 const char *kLockDirName = ".lock";
31 const char *kTempFileName = ".temp";
32 const char *kTempSymFileName = ".symtemp";
33 const char *kSymFileExtension = ".sym";
34 const char *kFSIllegalChars = "\\/:*?\"<>|";
35 
36 std::string GetEscapedHostname(const char *hostname) {
37  if (hostname == nullptr)
38  hostname = "unknown";
39  std::string result(hostname);
40  size_t size = result.size();
41  for (size_t i = 0; i < size; ++i) {
42  if ((result[i] >= 1 && result[i] <= 31) ||
43  strchr(kFSIllegalChars, result[i]) != nullptr)
44  result[i] = '_';
45  }
46  return result;
47 }
48 
49 class ModuleLock {
50 private:
51  File m_file;
52  std::unique_ptr<lldb_private::LockFile> m_lock;
53  FileSpec m_file_spec;
54 
55 public:
56  ModuleLock(const FileSpec &root_dir_spec, const UUID &uuid, Status &error);
57  void Delete();
58 };
59 
60 static FileSpec JoinPath(const FileSpec &path1, const char *path2) {
61  FileSpec result_spec(path1);
62  result_spec.AppendPathComponent(path2);
63  return result_spec;
64 }
65 
66 static Status MakeDirectory(const FileSpec &dir_path) {
67  namespace fs = llvm::sys::fs;
68 
69  return fs::create_directories(dir_path.GetPath(), true, fs::perms::owner_all);
70 }
71 
72 FileSpec GetModuleDirectory(const FileSpec &root_dir_spec, const UUID &uuid) {
73  const auto modules_dir_spec = JoinPath(root_dir_spec, kModulesSubdir);
74  return JoinPath(modules_dir_spec, uuid.GetAsString().c_str());
75 }
76 
77 FileSpec GetSymbolFileSpec(const FileSpec &module_file_spec) {
78  return FileSpec(module_file_spec.GetPath() + kSymFileExtension);
79 }
80 
81 void DeleteExistingModule(const FileSpec &root_dir_spec,
82  const FileSpec &sysroot_module_path_spec) {
84  UUID module_uuid;
85  {
86  auto module_sp =
87  std::make_shared<Module>(ModuleSpec(sysroot_module_path_spec));
88  module_uuid = module_sp->GetUUID();
89  }
90 
91  if (!module_uuid.IsValid())
92  return;
93 
94  Status error;
95  ModuleLock lock(root_dir_spec, module_uuid, error);
96  if (error.Fail()) {
97  if (log)
98  log->Printf("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 
115 void 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 
127 Status 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  const auto 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 
153 ModuleLock::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  FileSystem::Instance().Open(m_file, m_file_spec,
162  File::eOpenOptionWrite |
163  File::eOpenOptionCanCreate |
164  File::eOpenOptionCloseOnExec);
165  if (!m_file) {
166  error.SetErrorToErrno();
167  return;
168  }
169 
170  m_lock.reset(new lldb_private::LockFile(m_file.GetDescriptor()));
171  error = m_lock->WriteLock(0, 1);
172  if (error.Fail())
173  error.SetErrorStringWithFormat("Failed to lock file: %s",
174  error.AsCString());
175 }
176 
177 void ModuleLock::Delete() {
178  if (!m_file)
179  return;
180 
181  m_file.Close();
182  llvm::sys::fs::remove(m_file_spec.GetPath());
183 }
184 
185 /////////////////////////////////////////////////////////////////////////
186 
187 Status ModuleCache::Put(const FileSpec &root_dir_spec, const char *hostname,
188  const ModuleSpec &module_spec, const FileSpec &tmp_file,
189  const FileSpec &target_file) {
190  const auto module_spec_dir =
191  GetModuleDirectory(root_dir_spec, module_spec.GetUUID());
192  const auto module_file_path =
193  JoinPath(module_spec_dir, target_file.GetFilename().AsCString());
194 
195  const auto tmp_file_path = tmp_file.GetPath();
196  const auto err_code =
197  llvm::sys::fs::rename(tmp_file_path, module_file_path.GetPath());
198  if (err_code)
199  return Status("Failed to rename file %s to %s: %s", tmp_file_path.c_str(),
200  module_file_path.GetPath().c_str(),
201  err_code.message().c_str());
202 
203  const auto error = CreateHostSysRootModuleLink(
204  root_dir_spec, hostname, target_file, module_file_path, true);
205  if (error.Fail())
206  return Status("Failed to create link to %s: %s",
207  module_file_path.GetPath().c_str(), error.AsCString());
208  return Status();
209 }
210 
211 Status ModuleCache::Get(const FileSpec &root_dir_spec, const char *hostname,
212  const ModuleSpec &module_spec,
213  ModuleSP &cached_module_sp, bool *did_create_ptr) {
214  const auto find_it =
215  m_loaded_modules.find(module_spec.GetUUID().GetAsString());
216  if (find_it != m_loaded_modules.end()) {
217  cached_module_sp = (*find_it).second.lock();
218  if (cached_module_sp)
219  return Status();
220  m_loaded_modules.erase(find_it);
221  }
222 
223  const auto module_spec_dir =
224  GetModuleDirectory(root_dir_spec, module_spec.GetUUID());
225  const auto module_file_path = JoinPath(
226  module_spec_dir, module_spec.GetFileSpec().GetFilename().AsCString());
227 
228  if (!FileSystem::Instance().Exists(module_file_path))
229  return Status("Module %s not found", module_file_path.GetPath().c_str());
230  if (FileSystem::Instance().GetByteSize(module_file_path) !=
231  module_spec.GetObjectSize())
232  return Status("Module %s has invalid file size",
233  module_file_path.GetPath().c_str());
234 
235  // We may have already cached module but downloaded from an another host - in
236  // this case let's create a link to it.
237  auto error = CreateHostSysRootModuleLink(root_dir_spec, hostname,
238  module_spec.GetFileSpec(),
239  module_file_path, false);
240  if (error.Fail())
241  return Status("Failed to create link to %s: %s",
242  module_file_path.GetPath().c_str(), error.AsCString());
243 
244  auto cached_module_spec(module_spec);
245  cached_module_spec.GetUUID().Clear(); // Clear UUID since it may contain md5
246  // content hash instead of real UUID.
247  cached_module_spec.GetFileSpec() = module_file_path;
248  cached_module_spec.GetPlatformFileSpec() = module_spec.GetFileSpec();
249 
250  error = ModuleList::GetSharedModule(cached_module_spec, cached_module_sp,
251  nullptr, nullptr, did_create_ptr, false);
252  if (error.Fail())
253  return error;
254 
255  FileSpec symfile_spec = GetSymbolFileSpec(cached_module_sp->GetFileSpec());
256  if (FileSystem::Instance().Exists(symfile_spec))
257  cached_module_sp->SetSymbolFileFileSpec(symfile_spec);
258 
259  m_loaded_modules.insert(
260  std::make_pair(module_spec.GetUUID().GetAsString(), cached_module_sp));
261 
262  return Status();
263 }
264 
265 Status ModuleCache::GetAndPut(const FileSpec &root_dir_spec,
266  const char *hostname,
267  const ModuleSpec &module_spec,
268  const ModuleDownloader &module_downloader,
269  const SymfileDownloader &symfile_downloader,
270  lldb::ModuleSP &cached_module_sp,
271  bool *did_create_ptr) {
272  const auto module_spec_dir =
273  GetModuleDirectory(root_dir_spec, module_spec.GetUUID());
274  auto error = MakeDirectory(module_spec_dir);
275  if (error.Fail())
276  return error;
277 
278  ModuleLock lock(root_dir_spec, module_spec.GetUUID(), error);
279  if (error.Fail())
280  return Status("Failed to lock module %s: %s",
281  module_spec.GetUUID().GetAsString().c_str(),
282  error.AsCString());
283 
284  const auto escaped_hostname(GetEscapedHostname(hostname));
285  // Check local cache for a module.
286  error = Get(root_dir_spec, escaped_hostname.c_str(), module_spec,
287  cached_module_sp, did_create_ptr);
288  if (error.Success())
289  return error;
290 
291  const auto tmp_download_file_spec = JoinPath(module_spec_dir, kTempFileName);
292  error = module_downloader(module_spec, tmp_download_file_spec);
293  llvm::FileRemover tmp_file_remover(tmp_download_file_spec.GetPath());
294  if (error.Fail())
295  return Status("Failed to download module: %s", error.AsCString());
296 
297  // Put downloaded file into local module cache.
298  error = Put(root_dir_spec, escaped_hostname.c_str(), module_spec,
299  tmp_download_file_spec, module_spec.GetFileSpec());
300  if (error.Fail())
301  return Status("Failed to put module into cache: %s", error.AsCString());
302 
303  tmp_file_remover.releaseFile();
304  error = Get(root_dir_spec, escaped_hostname.c_str(), module_spec,
305  cached_module_sp, did_create_ptr);
306  if (error.Fail())
307  return error;
308 
309  // Fetching a symbol file for the module
310  const auto tmp_download_sym_file_spec =
311  JoinPath(module_spec_dir, kTempSymFileName);
312  error = symfile_downloader(cached_module_sp, tmp_download_sym_file_spec);
313  llvm::FileRemover tmp_symfile_remover(tmp_download_sym_file_spec.GetPath());
314  if (error.Fail())
315  // Failed to download a symfile but fetching the module was successful. The
316  // module might contain the necessary symbols and the debugging is also
317  // possible without a symfile.
318  return Status();
319 
320  error = Put(root_dir_spec, escaped_hostname.c_str(), module_spec,
321  tmp_download_sym_file_spec,
322  GetSymbolFileSpec(module_spec.GetFileSpec()));
323  if (error.Fail())
324  return Status("Failed to put symbol file into cache: %s",
325  error.AsCString());
326 
327  tmp_symfile_remover.releaseFile();
328 
329  FileSpec symfile_spec = GetSymbolFileSpec(cached_module_sp->GetFileSpec());
330  cached_module_sp->SetSymbolFileFileSpec(symfile_spec);
331  return Status();
332 }
ConstString & GetFilename()
Filename string get accessor.
Definition: FileSpec.cpp:369
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:224
A file utility class.
Definition: FileSpec.h:55
#define LIBLLDB_LOG_MODULES
Definition: Logging.h:35
A file class.
Definition: File.h:29
void SetErrorToErrno()
Set the current error to errno.
Definition: Status.cpp:223
uint64_t GetObjectSize() const
Definition: ModuleSpec.h:135
std::string GetAsString(llvm::StringRef separator="-") const
Definition: UUID.cpp:38
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:57
FileSpec & GetFileSpec()
Definition: ModuleSpec.h:75
std::function< Status(const lldb::ModuleSP &, const FileSpec &)> SymfileDownloader
Definition: ModuleCache.h:52
ConstString & GetDirectory()
Directory string get accessor.
Definition: FileSpec.cpp:363
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
Definition: SBAddress.h:15
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
Definition: Status.cpp:255
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:130
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:376
std::function< Status(const ModuleSpec &, const FileSpec &)> ModuleDownloader
Definition: ModuleCache.h:50
An error handling class.
Definition: Status.h:44