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 bool Reproducer::Initialized() { return InstanceImpl().operator bool(); }
77 
78 void Reproducer::Terminate() {
79   lldbassert(InstanceImpl() && "Already terminated.");
80   InstanceImpl().reset();
81 }
82 
83 Optional<Reproducer> &Reproducer::InstanceImpl() {
84   static Optional<Reproducer> g_reproducer;
85   return g_reproducer;
86 }
87 
88 const Generator *Reproducer::GetGenerator() const {
89   std::lock_guard<std::mutex> guard(m_mutex);
90   if (m_generator)
91     return &(*m_generator);
92   return nullptr;
93 }
94 
95 const Loader *Reproducer::GetLoader() const {
96   std::lock_guard<std::mutex> guard(m_mutex);
97   if (m_loader)
98     return &(*m_loader);
99   return nullptr;
100 }
101 
102 Generator *Reproducer::GetGenerator() {
103   std::lock_guard<std::mutex> guard(m_mutex);
104   if (m_generator)
105     return &(*m_generator);
106   return nullptr;
107 }
108 
109 Loader *Reproducer::GetLoader() {
110   std::lock_guard<std::mutex> guard(m_mutex);
111   if (m_loader)
112     return &(*m_loader);
113   return nullptr;
114 }
115 
116 llvm::Error Reproducer::SetCapture(llvm::Optional<FileSpec> root) {
117   std::lock_guard<std::mutex> guard(m_mutex);
118 
119   if (root && m_loader)
120     return make_error<StringError>(
121         "cannot generate a reproducer when replay one",
122         inconvertibleErrorCode());
123 
124   if (!root) {
125     m_generator.reset();
126     return Error::success();
127   }
128 
129   m_generator.emplace(*root);
130   return Error::success();
131 }
132 
133 llvm::Error Reproducer::SetReplay(llvm::Optional<FileSpec> root, bool passive) {
134   std::lock_guard<std::mutex> guard(m_mutex);
135 
136   if (root && m_generator)
137     return make_error<StringError>(
138         "cannot replay a reproducer when generating one",
139         inconvertibleErrorCode());
140 
141   if (!root) {
142     m_loader.reset();
143     return Error::success();
144   }
145 
146   m_loader.emplace(*root, passive);
147   if (auto e = m_loader->LoadIndex())
148     return e;
149 
150   return Error::success();
151 }
152 
153 FileSpec Reproducer::GetReproducerPath() const {
154   if (auto g = GetGenerator())
155     return g->GetRoot();
156   if (auto l = GetLoader())
157     return l->GetRoot();
158   return {};
159 }
160 
161 static FileSpec MakeAbsolute(const FileSpec &file_spec) {
162   SmallString<128> path;
163   file_spec.GetPath(path, false);
164   llvm::sys::fs::make_absolute(path);
165   return FileSpec(path, file_spec.GetPathStyle());
166 }
167 
168 Generator::Generator(FileSpec root) : m_root(MakeAbsolute(std::move(root))) {
169   GetOrCreate<repro::WorkingDirectoryProvider>();
170   GetOrCreate<repro::HomeDirectoryProvider>();
171 }
172 
173 Generator::~Generator() {
174   if (!m_done) {
175     if (m_auto_generate)
176       Keep();
177     else
178       Discard();
179   }
180 }
181 
182 ProviderBase *Generator::Register(std::unique_ptr<ProviderBase> provider) {
183   std::lock_guard<std::mutex> lock(m_providers_mutex);
184   std::pair<const void *, std::unique_ptr<ProviderBase>> key_value(
185       provider->DynamicClassID(), std::move(provider));
186   auto e = m_providers.insert(std::move(key_value));
187   return e.first->getSecond().get();
188 }
189 
190 void Generator::Keep() {
191   assert(!m_done);
192   m_done = true;
193 
194   for (auto &provider : m_providers)
195     provider.second->Keep();
196 
197   AddProvidersToIndex();
198 }
199 
200 void Generator::Discard() {
201   assert(!m_done);
202   m_done = true;
203 
204   for (auto &provider : m_providers)
205     provider.second->Discard();
206 
207   llvm::sys::fs::remove_directories(m_root.GetPath());
208 }
209 
210 void Generator::SetAutoGenerate(bool b) { m_auto_generate = b; }
211 
212 bool Generator::IsAutoGenerate() const { return m_auto_generate; }
213 
214 const FileSpec &Generator::GetRoot() const { return m_root; }
215 
216 void Generator::AddProvidersToIndex() {
217   FileSpec index = m_root;
218   index.AppendPathComponent("index.yaml");
219 
220   std::error_code EC;
221   auto strm = std::make_unique<raw_fd_ostream>(index.GetPath(), EC,
222                                                sys::fs::OpenFlags::OF_None);
223   yaml::Output yout(*strm);
224 
225   std::vector<std::string> files;
226   files.reserve(m_providers.size());
227   for (auto &provider : m_providers) {
228     files.emplace_back(provider.second->GetFile());
229   }
230 
231   yout << files;
232 }
233 
234 Loader::Loader(FileSpec root, bool passive)
235     : m_root(MakeAbsolute(std::move(root))), m_loaded(false),
236       m_passive_replay(passive) {}
237 
238 llvm::Error Loader::LoadIndex() {
239   if (m_loaded)
240     return llvm::Error::success();
241 
242   FileSpec index = m_root.CopyByAppendingPathComponent("index.yaml");
243 
244   auto error_or_file = MemoryBuffer::getFile(index.GetPath());
245   if (auto err = error_or_file.getError())
246     return make_error<StringError>("unable to load reproducer index", err);
247 
248   yaml::Input yin((*error_or_file)->getBuffer());
249   yin >> m_files;
250   if (auto err = yin.error())
251     return make_error<StringError>("unable to read reproducer index", err);
252 
253   // Sort files to speed up search.
254   llvm::sort(m_files);
255 
256   // Remember that we've loaded the index.
257   m_loaded = true;
258 
259   return llvm::Error::success();
260 }
261 
262 bool Loader::HasFile(StringRef file) {
263   assert(m_loaded);
264   auto it = std::lower_bound(m_files.begin(), m_files.end(), file.str());
265   return (it != m_files.end()) && (*it == file);
266 }
267