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 
9 #include "lldb/Target/ModuleCache.h"
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   FileUP m_file_up;
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) {
83   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES));
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     LLDB_LOGF(log, "Failed to lock module %s: %s",
98               module_uuid.GetAsString().c_str(), error.AsCString());
99   }
100 
101   namespace fs = llvm::sys::fs;
102   fs::file_status st;
103   if (status(sysroot_module_path_spec.GetPath(), st))
104     return;
105 
106   if (st.getLinkCount() > 2) // module is referred by other hosts.
107     return;
108 
109   const auto module_spec_dir = GetModuleDirectory(root_dir_spec, module_uuid);
110   llvm::sys::fs::remove_directories(module_spec_dir.GetPath());
111   lock.Delete();
112 }
113 
114 void DecrementRefExistingModule(const FileSpec &root_dir_spec,
115                                 const FileSpec &sysroot_module_path_spec) {
116   // Remove $platform/.cache/$uuid folder if nobody else references it.
117   DeleteExistingModule(root_dir_spec, sysroot_module_path_spec);
118 
119   // Remove sysroot link.
120   llvm::sys::fs::remove(sysroot_module_path_spec.GetPath());
121 
122   FileSpec symfile_spec = GetSymbolFileSpec(sysroot_module_path_spec);
123   llvm::sys::fs::remove(symfile_spec.GetPath());
124 }
125 
126 Status CreateHostSysRootModuleLink(const FileSpec &root_dir_spec,
127                                    const char *hostname,
128                                    const FileSpec &platform_module_spec,
129                                    const FileSpec &local_module_spec,
130                                    bool delete_existing) {
131   const auto sysroot_module_path_spec =
132       JoinPath(JoinPath(root_dir_spec, hostname),
133                platform_module_spec.GetPath().c_str());
134   if (FileSystem::Instance().Exists(sysroot_module_path_spec)) {
135     if (!delete_existing)
136       return Status();
137 
138     DecrementRefExistingModule(root_dir_spec, sysroot_module_path_spec);
139   }
140 
141   const auto error = MakeDirectory(
142       FileSpec(sysroot_module_path_spec.GetDirectory().AsCString()));
143   if (error.Fail())
144     return error;
145 
146   return llvm::sys::fs::create_hard_link(local_module_spec.GetPath(),
147                                          sysroot_module_path_spec.GetPath());
148 }
149 
150 } // namespace
151 
152 ModuleLock::ModuleLock(const FileSpec &root_dir_spec, const UUID &uuid,
153                        Status &error) {
154   const auto lock_dir_spec = JoinPath(root_dir_spec, kLockDirName);
155   error = MakeDirectory(lock_dir_spec);
156   if (error.Fail())
157     return;
158 
159   m_file_spec = JoinPath(lock_dir_spec, uuid.GetAsString().c_str());
160 
161   auto file = FileSystem::Instance().Open(
162       m_file_spec, File::eOpenOptionWrite | File::eOpenOptionCanCreate |
163                        File::eOpenOptionCloseOnExec);
164   if (file)
165     m_file_up = std::move(file.get());
166   else {
167     m_file_up.reset();
168     error = Status(file.takeError());
169     return;
170   }
171 
172   m_lock = std::make_unique<lldb_private::LockFile>(m_file_up->GetDescriptor());
173   error = m_lock->WriteLock(0, 1);
174   if (error.Fail())
175     error.SetErrorStringWithFormat("Failed to lock file: %s",
176                                    error.AsCString());
177 }
178 
179 void ModuleLock::Delete() {
180   if (!m_file_up)
181     return;
182 
183   m_file_up->Close();
184   m_file_up.reset();
185   llvm::sys::fs::remove(m_file_spec.GetPath());
186 }
187 
188 /////////////////////////////////////////////////////////////////////////
189 
190 Status ModuleCache::Put(const FileSpec &root_dir_spec, const char *hostname,
191                         const ModuleSpec &module_spec, const FileSpec &tmp_file,
192                         const FileSpec &target_file) {
193   const auto module_spec_dir =
194       GetModuleDirectory(root_dir_spec, module_spec.GetUUID());
195   const auto module_file_path =
196       JoinPath(module_spec_dir, target_file.GetFilename().AsCString());
197 
198   const auto tmp_file_path = tmp_file.GetPath();
199   const auto err_code =
200       llvm::sys::fs::rename(tmp_file_path, module_file_path.GetPath());
201   if (err_code)
202     return Status("Failed to rename file %s to %s: %s", tmp_file_path.c_str(),
203                   module_file_path.GetPath().c_str(),
204                   err_code.message().c_str());
205 
206   const auto error = CreateHostSysRootModuleLink(
207       root_dir_spec, hostname, target_file, module_file_path, true);
208   if (error.Fail())
209     return Status("Failed to create link to %s: %s",
210                   module_file_path.GetPath().c_str(), error.AsCString());
211   return Status();
212 }
213 
214 Status ModuleCache::Get(const FileSpec &root_dir_spec, const char *hostname,
215                         const ModuleSpec &module_spec,
216                         ModuleSP &cached_module_sp, bool *did_create_ptr) {
217   const auto find_it =
218       m_loaded_modules.find(module_spec.GetUUID().GetAsString());
219   if (find_it != m_loaded_modules.end()) {
220     cached_module_sp = (*find_it).second.lock();
221     if (cached_module_sp)
222       return Status();
223     m_loaded_modules.erase(find_it);
224   }
225 
226   const auto module_spec_dir =
227       GetModuleDirectory(root_dir_spec, module_spec.GetUUID());
228   const auto module_file_path = JoinPath(
229       module_spec_dir, module_spec.GetFileSpec().GetFilename().AsCString());
230 
231   if (!FileSystem::Instance().Exists(module_file_path))
232     return Status("Module %s not found", module_file_path.GetPath().c_str());
233   if (FileSystem::Instance().GetByteSize(module_file_path) !=
234       module_spec.GetObjectSize())
235     return Status("Module %s has invalid file size",
236                   module_file_path.GetPath().c_str());
237 
238   // We may have already cached module but downloaded from an another host - in
239   // this case let's create a link to it.
240   auto error = CreateHostSysRootModuleLink(root_dir_spec, hostname,
241                                            module_spec.GetFileSpec(),
242                                            module_file_path, false);
243   if (error.Fail())
244     return Status("Failed to create link to %s: %s",
245                   module_file_path.GetPath().c_str(), error.AsCString());
246 
247   auto cached_module_spec(module_spec);
248   cached_module_spec.GetUUID().Clear(); // Clear UUID since it may contain md5
249                                         // content hash instead of real UUID.
250   cached_module_spec.GetFileSpec() = module_file_path;
251   cached_module_spec.GetPlatformFileSpec() = module_spec.GetFileSpec();
252 
253   error = ModuleList::GetSharedModule(cached_module_spec, cached_module_sp,
254                                       nullptr, nullptr, did_create_ptr, false);
255   if (error.Fail())
256     return error;
257 
258   FileSpec symfile_spec = GetSymbolFileSpec(cached_module_sp->GetFileSpec());
259   if (FileSystem::Instance().Exists(symfile_spec))
260     cached_module_sp->SetSymbolFileFileSpec(symfile_spec);
261 
262   m_loaded_modules.insert(
263       std::make_pair(module_spec.GetUUID().GetAsString(), cached_module_sp));
264 
265   return Status();
266 }
267 
268 Status ModuleCache::GetAndPut(const FileSpec &root_dir_spec,
269                               const char *hostname,
270                               const ModuleSpec &module_spec,
271                               const ModuleDownloader &module_downloader,
272                               const SymfileDownloader &symfile_downloader,
273                               lldb::ModuleSP &cached_module_sp,
274                               bool *did_create_ptr) {
275   const auto module_spec_dir =
276       GetModuleDirectory(root_dir_spec, module_spec.GetUUID());
277   auto error = MakeDirectory(module_spec_dir);
278   if (error.Fail())
279     return error;
280 
281   ModuleLock lock(root_dir_spec, module_spec.GetUUID(), error);
282   if (error.Fail())
283     return Status("Failed to lock module %s: %s",
284                   module_spec.GetUUID().GetAsString().c_str(),
285                   error.AsCString());
286 
287   const auto escaped_hostname(GetEscapedHostname(hostname));
288   // Check local cache for a module.
289   error = Get(root_dir_spec, escaped_hostname.c_str(), module_spec,
290               cached_module_sp, did_create_ptr);
291   if (error.Success())
292     return error;
293 
294   const auto tmp_download_file_spec = JoinPath(module_spec_dir, kTempFileName);
295   error = module_downloader(module_spec, tmp_download_file_spec);
296   llvm::FileRemover tmp_file_remover(tmp_download_file_spec.GetPath());
297   if (error.Fail())
298     return Status("Failed to download module: %s", error.AsCString());
299 
300   // Put downloaded file into local module cache.
301   error = Put(root_dir_spec, escaped_hostname.c_str(), module_spec,
302               tmp_download_file_spec, module_spec.GetFileSpec());
303   if (error.Fail())
304     return Status("Failed to put module into cache: %s", error.AsCString());
305 
306   tmp_file_remover.releaseFile();
307   error = Get(root_dir_spec, escaped_hostname.c_str(), module_spec,
308               cached_module_sp, did_create_ptr);
309   if (error.Fail())
310     return error;
311 
312   // Fetching a symbol file for the module
313   const auto tmp_download_sym_file_spec =
314       JoinPath(module_spec_dir, kTempSymFileName);
315   error = symfile_downloader(cached_module_sp, tmp_download_sym_file_spec);
316   llvm::FileRemover tmp_symfile_remover(tmp_download_sym_file_spec.GetPath());
317   if (error.Fail())
318     // Failed to download a symfile but fetching the module was successful. The
319     // module might contain the necessary symbols and the debugging is also
320     // possible without a symfile.
321     return Status();
322 
323   error = Put(root_dir_spec, escaped_hostname.c_str(), module_spec,
324               tmp_download_sym_file_spec,
325               GetSymbolFileSpec(module_spec.GetFileSpec()));
326   if (error.Fail())
327     return Status("Failed to put symbol file into cache: %s",
328                   error.AsCString());
329 
330   tmp_symfile_remover.releaseFile();
331 
332   FileSpec symfile_spec = GetSymbolFileSpec(cached_module_sp->GetFileSpec());
333   cached_module_sp->SetSymbolFileFileSpec(symfile_spec);
334   return Status();
335 }
336