1 //===-- Reproducer.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/Utility/Reproducer.h"
10 #include "lldb/Utility/LLDBAssert.h"
11 #include "lldb/Utility/ReproducerProvider.h"
12 
13 #include "llvm/Support/FileSystem.h"
14 #include "llvm/Support/Threading.h"
15 #include "llvm/Support/raw_ostream.h"
16 
17 using namespace lldb_private;
18 using namespace lldb_private::repro;
19 using namespace llvm;
20 using namespace llvm::yaml;
21 
22 static llvm::Optional<bool> GetEnv(const char *var) {
23   std::string val = llvm::StringRef(getenv(var)).lower();
24   if (val == "0" || val == "off")
25     return false;
26   if (val == "1" || val == "on")
27     return true;
28   return {};
29 }
30 
31 Reproducer &Reproducer::Instance() { return *InstanceImpl(); }
32 
33 llvm::Error Reproducer::Initialize(ReproducerMode mode,
34                                    llvm::Optional<FileSpec> root) {
35   lldbassert(!InstanceImpl() && "Already initialized.");
36   InstanceImpl().emplace();
37 
38   // The environment can override the capture mode.
39   if (mode != ReproducerMode::Replay) {
40     if (llvm::Optional<bool> override = GetEnv("LLDB_CAPTURE_REPRODUCER")) {
41       if (*override)
42         mode = ReproducerMode::Capture;
43       else
44         mode = ReproducerMode::Off;
45     }
46   }
47 
48   switch (mode) {
49   case ReproducerMode::Capture: {
50     if (!root) {
51       SmallString<128> repro_dir;
52       auto ec = sys::fs::createUniqueDirectory("reproducer", repro_dir);
53       if (ec)
54         return make_error<StringError>(
55             "unable to create unique reproducer directory", ec);
56       root.emplace(repro_dir);
57     } else {
58       auto ec = sys::fs::create_directory(root->GetPath());
59       if (ec)
60         return make_error<StringError>("unable to create reproducer directory",
61                                        ec);
62     }
63     return Instance().SetCapture(root);
64   } break;
65   case ReproducerMode::Replay:
66     return Instance().SetReplay(root, /*passive*/ false);
67   case ReproducerMode::PassiveReplay:
68     return Instance().SetReplay(root, /*passive*/ true);
69   case ReproducerMode::Off:
70     break;
71   };
72 
73   return Error::success();
74 }
75 
76 void Reproducer::Initialize() {
77   llvm::cantFail(Initialize(repro::ReproducerMode::Off, llvm::None));
78 }
79 
80 bool Reproducer::Initialized() { return InstanceImpl().operator bool(); }
81 
82 void Reproducer::Terminate() {
83   lldbassert(InstanceImpl() && "Already terminated.");
84   InstanceImpl().reset();
85 }
86 
87 Optional<Reproducer> &Reproducer::InstanceImpl() {
88   static Optional<Reproducer> g_reproducer;
89   return g_reproducer;
90 }
91 
92 const Generator *Reproducer::GetGenerator() const {
93   std::lock_guard<std::mutex> guard(m_mutex);
94   if (m_generator)
95     return &(*m_generator);
96   return nullptr;
97 }
98 
99 const Loader *Reproducer::GetLoader() const {
100   std::lock_guard<std::mutex> guard(m_mutex);
101   if (m_loader)
102     return &(*m_loader);
103   return nullptr;
104 }
105 
106 Generator *Reproducer::GetGenerator() {
107   std::lock_guard<std::mutex> guard(m_mutex);
108   if (m_generator)
109     return &(*m_generator);
110   return nullptr;
111 }
112 
113 Loader *Reproducer::GetLoader() {
114   std::lock_guard<std::mutex> guard(m_mutex);
115   if (m_loader)
116     return &(*m_loader);
117   return nullptr;
118 }
119 
120 llvm::Error Reproducer::SetCapture(llvm::Optional<FileSpec> root) {
121   std::lock_guard<std::mutex> guard(m_mutex);
122 
123   if (root && m_loader)
124     return make_error<StringError>(
125         "cannot generate a reproducer when replay one",
126         inconvertibleErrorCode());
127 
128   if (!root) {
129     m_generator.reset();
130     return Error::success();
131   }
132 
133   m_generator.emplace(*root);
134   return Error::success();
135 }
136 
137 llvm::Error Reproducer::SetReplay(llvm::Optional<FileSpec> root, bool passive) {
138   std::lock_guard<std::mutex> guard(m_mutex);
139 
140   if (root && m_generator)
141     return make_error<StringError>(
142         "cannot replay a reproducer when generating one",
143         inconvertibleErrorCode());
144 
145   if (!root) {
146     m_loader.reset();
147     return Error::success();
148   }
149 
150   m_loader.emplace(*root, passive);
151   if (auto e = m_loader->LoadIndex())
152     return e;
153 
154   return Error::success();
155 }
156 
157 FileSpec Reproducer::GetReproducerPath() const {
158   if (auto g = GetGenerator())
159     return g->GetRoot();
160   if (auto l = GetLoader())
161     return l->GetRoot();
162   return {};
163 }
164 
165 static FileSpec MakeAbsolute(const FileSpec &file_spec) {
166   SmallString<128> path;
167   file_spec.GetPath(path, false);
168   llvm::sys::fs::make_absolute(path);
169   return FileSpec(path, file_spec.GetPathStyle());
170 }
171 
172 Generator::Generator(FileSpec root) : m_root(MakeAbsolute(std::move(root))) {
173   GetOrCreate<repro::WorkingDirectoryProvider>();
174   GetOrCreate<repro::HomeDirectoryProvider>();
175 }
176 
177 Generator::~Generator() {
178   if (!m_done) {
179     if (m_auto_generate) {
180       Keep();
181       llvm::cantFail(Finalize(GetRoot()));
182     } else {
183       Discard();
184     }
185   }
186 }
187 
188 ProviderBase *Generator::Register(std::unique_ptr<ProviderBase> provider) {
189   std::lock_guard<std::mutex> lock(m_providers_mutex);
190   std::pair<const void *, std::unique_ptr<ProviderBase>> key_value(
191       provider->DynamicClassID(), std::move(provider));
192   auto e = m_providers.insert(std::move(key_value));
193   return e.first->getSecond().get();
194 }
195 
196 void Generator::Keep() {
197   assert(!m_done);
198   m_done = true;
199 
200   for (auto &provider : m_providers)
201     provider.second->Keep();
202 
203   AddProvidersToIndex();
204 }
205 
206 void Generator::Discard() {
207   assert(!m_done);
208   m_done = true;
209 
210   for (auto &provider : m_providers)
211     provider.second->Discard();
212 
213   llvm::sys::fs::remove_directories(m_root.GetPath());
214 }
215 
216 void Generator::SetAutoGenerate(bool b) { m_auto_generate = b; }
217 
218 bool Generator::IsAutoGenerate() const { return m_auto_generate; }
219 
220 const FileSpec &Generator::GetRoot() const { return m_root; }
221 
222 void Generator::AddProvidersToIndex() {
223   FileSpec index = m_root;
224   index.AppendPathComponent("index.yaml");
225 
226   std::error_code EC;
227   auto strm = std::make_unique<raw_fd_ostream>(index.GetPath(), EC,
228                                                sys::fs::OpenFlags::OF_None);
229   yaml::Output yout(*strm);
230 
231   std::vector<std::string> files;
232   files.reserve(m_providers.size());
233   for (auto &provider : m_providers) {
234     files.emplace_back(provider.second->GetFile());
235   }
236 
237   yout << files;
238 }
239 
240 Loader::Loader(FileSpec root, bool passive)
241     : m_root(MakeAbsolute(std::move(root))), m_loaded(false),
242       m_passive_replay(passive) {}
243 
244 llvm::Error Loader::LoadIndex() {
245   if (m_loaded)
246     return llvm::Error::success();
247 
248   FileSpec index = m_root.CopyByAppendingPathComponent("index.yaml");
249 
250   auto error_or_file = MemoryBuffer::getFile(index.GetPath());
251   if (auto err = error_or_file.getError())
252     return make_error<StringError>("unable to load reproducer index", err);
253 
254   yaml::Input yin((*error_or_file)->getBuffer());
255   yin >> m_files;
256   if (auto err = yin.error())
257     return make_error<StringError>("unable to read reproducer index", err);
258 
259   // Sort files to speed up search.
260   llvm::sort(m_files);
261 
262   // Remember that we've loaded the index.
263   m_loaded = true;
264 
265   return llvm::Error::success();
266 }
267 
268 bool Loader::HasFile(StringRef file) {
269   assert(m_loaded);
270   auto it = std::lower_bound(m_files.begin(), m_files.end(), file.str());
271   return (it != m_files.end()) && (*it == file);
272 }
273 
274 void Verifier::Verify(
275     llvm::function_ref<void(llvm::StringRef)> error_callback,
276     llvm::function_ref<void(llvm::StringRef)> warning_callback,
277     llvm::function_ref<void(llvm::StringRef)> note_callack) const {
278   if (!m_loader) {
279     error_callback("invalid loader");
280     return;
281   }
282 
283   FileSpec vfs_mapping = m_loader->GetFile<FileProvider::Info>();
284   ErrorOr<std::unique_ptr<MemoryBuffer>> buffer =
285       vfs::getRealFileSystem()->getBufferForFile(vfs_mapping.GetPath());
286   if (!buffer) {
287     error_callback("unable to read files: " + buffer.getError().message());
288     return;
289   }
290 
291   IntrusiveRefCntPtr<vfs::FileSystem> vfs = vfs::getVFSFromYAML(
292       std::move(buffer.get()), nullptr, vfs_mapping.GetPath());
293   if (!vfs) {
294     error_callback("unable to initialize the virtual file system");
295     return;
296   }
297 
298   auto &redirecting_vfs = static_cast<vfs::RedirectingFileSystem &>(*vfs);
299   redirecting_vfs.setFallthrough(false);
300 
301   {
302     llvm::Expected<std::string> working_dir =
303         GetDirectoryFrom<WorkingDirectoryProvider>(m_loader);
304     if (working_dir) {
305       if (!vfs->exists(*working_dir))
306         warning_callback("working directory '" + *working_dir + "' not in VFS");
307       vfs->setCurrentWorkingDirectory(*working_dir);
308     } else {
309       warning_callback("no working directory in reproducer: " +
310                        toString(working_dir.takeError()));
311     }
312   }
313 
314   {
315     llvm::Expected<std::string> home_dir =
316         GetDirectoryFrom<HomeDirectoryProvider>(m_loader);
317     if (home_dir) {
318       if (!vfs->exists(*home_dir))
319         warning_callback("home directory '" + *home_dir + "' not in VFS");
320     } else {
321       warning_callback("no home directory in reproducer: " +
322                        toString(home_dir.takeError()));
323     }
324   }
325 
326   {
327     Expected<std::string> symbol_files =
328         m_loader->LoadBuffer<SymbolFileProvider>();
329     if (symbol_files) {
330       std::vector<SymbolFileProvider::Entry> entries;
331       llvm::yaml::Input yin(*symbol_files);
332       yin >> entries;
333       for (const auto &entry : entries) {
334         if (!entry.module_path.empty() && !vfs->exists(entry.module_path)) {
335           warning_callback("'" + entry.module_path + "': module path for " +
336                            entry.uuid + " not in VFS");
337         }
338         if (!entry.symbol_path.empty() && !vfs->exists(entry.symbol_path)) {
339           warning_callback("'" + entry.symbol_path + "': symbol path for " +
340                            entry.uuid + " not in VFS");
341         }
342       }
343     } else {
344       llvm::consumeError(symbol_files.takeError());
345     }
346   }
347 
348   // Missing files in the VFS are notes rather than warnings. Because the VFS
349   // is a snapshot, temporary files could have been removed between when they
350   // were recorded and when the reproducer was generated.
351   std::vector<llvm::StringRef> roots = redirecting_vfs.getRoots();
352   for (llvm::StringRef root : roots) {
353     std::error_code ec;
354     vfs::recursive_directory_iterator iter(*vfs, root, ec);
355     vfs::recursive_directory_iterator end;
356     for (; iter != end && !ec; iter.increment(ec)) {
357       ErrorOr<vfs::Status> status = vfs->status(iter->path());
358       if (!status)
359         note_callack("'" + iter->path().str() +
360                      "': " + status.getError().message());
361     }
362   }
363 }
364 
365 static llvm::Error addPaths(StringRef path,
366                             function_ref<void(StringRef)> callback) {
367   auto buffer = llvm::MemoryBuffer::getFile(path);
368   if (!buffer)
369     return errorCodeToError(buffer.getError());
370 
371   SmallVector<StringRef, 0> paths;
372   (*buffer)->getBuffer().split(paths, '\0');
373   for (StringRef p : paths) {
374     if (!p.empty())
375       callback(p);
376   }
377 
378   return errorCodeToError(llvm::sys::fs::remove(path));
379 }
380 
381 llvm::Error repro::Finalize(Loader *loader) {
382   if (!loader)
383     return make_error<StringError>("invalid loader",
384                                    llvm::inconvertibleErrorCode());
385 
386   FileSpec reproducer_root = loader->GetRoot();
387   std::string files_path =
388       reproducer_root.CopyByAppendingPathComponent("files.txt").GetPath();
389   std::string dirs_path =
390       reproducer_root.CopyByAppendingPathComponent("dirs.txt").GetPath();
391 
392   FileCollector collector(
393       reproducer_root.CopyByAppendingPathComponent("root").GetPath(),
394       reproducer_root.GetPath());
395 
396   if (Error e =
397           addPaths(files_path, [&](StringRef p) { collector.addFile(p); }))
398     return e;
399 
400   if (Error e =
401           addPaths(dirs_path, [&](StringRef p) { collector.addDirectory(p); }))
402     return e;
403 
404   FileSpec mapping =
405       reproducer_root.CopyByAppendingPathComponent(FileProvider::Info::file);
406   if (auto ec = collector.copyFiles(/*stop_on_error=*/false))
407     return errorCodeToError(ec);
408   collector.writeMapping(mapping.GetPath());
409 
410   return llvm::Error::success();
411 }
412 
413 llvm::Error repro::Finalize(const FileSpec &root) {
414   Loader loader(root);
415   if (Error e = loader.LoadIndex())
416     return e;
417   return Finalize(&loader);
418 }
419