1 //===-- Reproducer.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 
9 #include "lldb/Utility/Reproducer.h"
10 #include "lldb/Utility/LLDBAssert.h"
11 
12 #include "llvm/Support/FileSystem.h"
13 #include "llvm/Support/Threading.h"
14 #include "llvm/Support/raw_ostream.h"
15 
16 using namespace lldb_private;
17 using namespace lldb_private::repro;
18 using namespace llvm;
19 using namespace llvm::yaml;
20 
21 Reproducer &Reproducer::Instance() { return *InstanceImpl(); }
22 
23 llvm::Error Reproducer::Initialize(ReproducerMode mode,
24                                    llvm::Optional<FileSpec> root) {
25   lldbassert(!InstanceImpl() && "Already initialized.");
26   InstanceImpl().emplace();
27 
28   switch (mode) {
29   case ReproducerMode::Capture: {
30     if (!root) {
31       SmallString<128> repro_dir;
32       auto ec = sys::fs::createUniqueDirectory("reproducer", repro_dir);
33       if (ec)
34         return make_error<StringError>(
35             "unable to create unique reproducer directory", ec);
36       root.emplace(repro_dir);
37     } else {
38       auto ec = sys::fs::create_directory(root->GetPath());
39       if (ec)
40         return make_error<StringError>("unable to create reproducer directory",
41                                        ec);
42     }
43     return Instance().SetCapture(root);
44   } break;
45   case ReproducerMode::Replay:
46     return Instance().SetReplay(root);
47   case ReproducerMode::Off:
48     break;
49   };
50 
51   return Error::success();
52 }
53 
54 bool Reproducer::Initialized() { return InstanceImpl().operator bool(); }
55 
56 void Reproducer::Terminate() {
57   lldbassert(InstanceImpl() && "Already terminated.");
58   InstanceImpl().reset();
59 }
60 
61 Optional<Reproducer> &Reproducer::InstanceImpl() {
62   static Optional<Reproducer> g_reproducer;
63   return g_reproducer;
64 }
65 
66 const Generator *Reproducer::GetGenerator() const {
67   std::lock_guard<std::mutex> guard(m_mutex);
68   if (m_generator)
69     return &(*m_generator);
70   return nullptr;
71 }
72 
73 const Loader *Reproducer::GetLoader() const {
74   std::lock_guard<std::mutex> guard(m_mutex);
75   if (m_loader)
76     return &(*m_loader);
77   return nullptr;
78 }
79 
80 Generator *Reproducer::GetGenerator() {
81   std::lock_guard<std::mutex> guard(m_mutex);
82   if (m_generator)
83     return &(*m_generator);
84   return nullptr;
85 }
86 
87 Loader *Reproducer::GetLoader() {
88   std::lock_guard<std::mutex> guard(m_mutex);
89   if (m_loader)
90     return &(*m_loader);
91   return nullptr;
92 }
93 
94 llvm::Error Reproducer::SetCapture(llvm::Optional<FileSpec> root) {
95   std::lock_guard<std::mutex> guard(m_mutex);
96 
97   if (root && m_loader)
98     return make_error<StringError>(
99         "cannot generate a reproducer when replay one",
100         inconvertibleErrorCode());
101 
102   if (!root) {
103     m_generator.reset();
104     return Error::success();
105   }
106 
107   m_generator.emplace(*root);
108   return Error::success();
109 }
110 
111 llvm::Error Reproducer::SetReplay(llvm::Optional<FileSpec> root) {
112   std::lock_guard<std::mutex> guard(m_mutex);
113 
114   if (root && m_generator)
115     return make_error<StringError>(
116         "cannot replay a reproducer when generating one",
117         inconvertibleErrorCode());
118 
119   if (!root) {
120     m_loader.reset();
121     return Error::success();
122   }
123 
124   m_loader.emplace(*root);
125   if (auto e = m_loader->LoadIndex())
126     return e;
127 
128   return Error::success();
129 }
130 
131 FileSpec Reproducer::GetReproducerPath() const {
132   if (auto g = GetGenerator())
133     return g->GetRoot();
134   if (auto l = GetLoader())
135     return l->GetRoot();
136   return {};
137 }
138 
139 static FileSpec MakeAbsolute(FileSpec file_spec) {
140   SmallString<128> path;
141   file_spec.GetPath(path, false);
142   llvm::sys::fs::make_absolute(path);
143   return FileSpec(path, file_spec.GetPathStyle());
144 }
145 
146 Generator::Generator(FileSpec root) : m_root(MakeAbsolute(std::move(root))) {
147   GetOrCreate<repro::WorkingDirectoryProvider>();
148 }
149 
150 Generator::~Generator() {
151   if (!m_done)
152     Discard();
153 }
154 
155 ProviderBase *Generator::Register(std::unique_ptr<ProviderBase> provider) {
156   std::lock_guard<std::mutex> lock(m_providers_mutex);
157   std::pair<const void *, std::unique_ptr<ProviderBase>> key_value(
158       provider->DynamicClassID(), std::move(provider));
159   auto e = m_providers.insert(std::move(key_value));
160   return e.first->getSecond().get();
161 }
162 
163 void Generator::Keep() {
164   assert(!m_done);
165   m_done = true;
166 
167   for (auto &provider : m_providers)
168     provider.second->Keep();
169 
170   AddProvidersToIndex();
171 }
172 
173 void Generator::Discard() {
174   assert(!m_done);
175   m_done = true;
176 
177   for (auto &provider : m_providers)
178     provider.second->Discard();
179 
180   llvm::sys::fs::remove_directories(m_root.GetPath());
181 }
182 
183 const FileSpec &Generator::GetRoot() const { return m_root; }
184 
185 void Generator::AddProvidersToIndex() {
186   FileSpec index = m_root;
187   index.AppendPathComponent("index.yaml");
188 
189   std::error_code EC;
190   auto strm = std::make_unique<raw_fd_ostream>(index.GetPath(), EC,
191                                                sys::fs::OpenFlags::OF_None);
192   yaml::Output yout(*strm);
193 
194   std::vector<std::string> files;
195   files.reserve(m_providers.size());
196   for (auto &provider : m_providers) {
197     files.emplace_back(provider.second->GetFile());
198   }
199 
200   yout << files;
201 }
202 
203 Loader::Loader(FileSpec root)
204     : m_root(MakeAbsolute(std::move(root))), m_loaded(false) {}
205 
206 llvm::Error Loader::LoadIndex() {
207   if (m_loaded)
208     return llvm::Error::success();
209 
210   FileSpec index = m_root.CopyByAppendingPathComponent("index.yaml");
211 
212   auto error_or_file = MemoryBuffer::getFile(index.GetPath());
213   if (auto err = error_or_file.getError())
214     return make_error<StringError>("unable to load reproducer index", err);
215 
216   yaml::Input yin((*error_or_file)->getBuffer());
217   yin >> m_files;
218   if (auto err = yin.error())
219     return make_error<StringError>("unable to read reproducer index", err);
220 
221   // Sort files to speed up search.
222   llvm::sort(m_files);
223 
224   // Remember that we've loaded the index.
225   m_loaded = true;
226 
227   return llvm::Error::success();
228 }
229 
230 bool Loader::HasFile(StringRef file) {
231   assert(m_loaded);
232   auto it = std::lower_bound(m_files.begin(), m_files.end(), file.str());
233   return (it != m_files.end()) && (*it == file);
234 }
235 
236 llvm::Expected<std::unique_ptr<DataRecorder>>
237 DataRecorder::Create(const FileSpec &filename) {
238   std::error_code ec;
239   auto recorder = std::make_unique<DataRecorder>(std::move(filename), ec);
240   if (ec)
241     return llvm::errorCodeToError(ec);
242   return std::move(recorder);
243 }
244 
245 DataRecorder *CommandProvider::GetNewDataRecorder() {
246   std::size_t i = m_data_recorders.size() + 1;
247   std::string filename = (llvm::Twine(Info::name) + llvm::Twine("-") +
248                           llvm::Twine(i) + llvm::Twine(".txt"))
249                              .str();
250   auto recorder_or_error =
251       DataRecorder::Create(GetRoot().CopyByAppendingPathComponent(filename));
252   if (!recorder_or_error) {
253     llvm::consumeError(recorder_or_error.takeError());
254     return nullptr;
255   }
256 
257   m_data_recorders.push_back(std::move(*recorder_or_error));
258   return m_data_recorders.back().get();
259 }
260 
261 void CommandProvider::Keep() {
262   std::vector<std::string> files;
263   for (auto &recorder : m_data_recorders) {
264     recorder->Stop();
265     files.push_back(recorder->GetFilename().GetPath());
266   }
267 
268   FileSpec file = GetRoot().CopyByAppendingPathComponent(Info::file);
269   std::error_code ec;
270   llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_Text);
271   if (ec)
272     return;
273   yaml::Output yout(os);
274   yout << files;
275 }
276 
277 void CommandProvider::Discard() { m_data_recorders.clear(); }
278 
279 void VersionProvider::Keep() {
280   FileSpec file = GetRoot().CopyByAppendingPathComponent(Info::file);
281   std::error_code ec;
282   llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_Text);
283   if (ec)
284     return;
285   os << m_version << "\n";
286 }
287 
288 void WorkingDirectoryProvider::Keep() {
289   FileSpec file = GetRoot().CopyByAppendingPathComponent(Info::file);
290   std::error_code ec;
291   llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_Text);
292   if (ec)
293     return;
294   os << m_cwd << "\n";
295 }
296 
297 llvm::raw_ostream *ProcessGDBRemoteProvider::GetHistoryStream() {
298   FileSpec history_file = GetRoot().CopyByAppendingPathComponent(Info::file);
299 
300   std::error_code EC;
301   m_stream_up = std::make_unique<raw_fd_ostream>(history_file.GetPath(), EC,
302                                                  sys::fs::OpenFlags::OF_Text);
303   return m_stream_up.get();
304 }
305 
306 std::unique_ptr<CommandLoader> CommandLoader::Create(Loader *loader) {
307   if (!loader)
308     return {};
309 
310   FileSpec file = loader->GetFile<repro::CommandProvider::Info>();
311   if (!file)
312     return {};
313 
314   auto error_or_file = llvm::MemoryBuffer::getFile(file.GetPath());
315   if (auto err = error_or_file.getError())
316     return {};
317 
318   std::vector<std::string> files;
319   llvm::yaml::Input yin((*error_or_file)->getBuffer());
320   yin >> files;
321 
322   if (auto err = yin.error())
323     return {};
324 
325   for (auto &file : files) {
326     FileSpec absolute_path =
327         loader->GetRoot().CopyByAppendingPathComponent(file);
328     file = absolute_path.GetPath();
329   }
330 
331   return std::make_unique<CommandLoader>(std::move(files));
332 }
333 
334 llvm::Optional<std::string> CommandLoader::GetNextFile() {
335   if (m_index >= m_files.size())
336     return {};
337   return m_files[m_index++];
338 }
339 
340 void ProviderBase::anchor() {}
341 char CommandProvider::ID = 0;
342 char FileProvider::ID = 0;
343 char ProcessGDBRemoteProvider::ID = 0;
344 char ProviderBase::ID = 0;
345 char VersionProvider::ID = 0;
346 char WorkingDirectoryProvider::ID = 0;
347 const char *CommandProvider::Info::file = "command-interpreter.yaml";
348 const char *CommandProvider::Info::name = "command-interpreter";
349 const char *FileProvider::Info::file = "files.yaml";
350 const char *FileProvider::Info::name = "files";
351 const char *ProcessGDBRemoteProvider::Info::file = "gdb-remote.yaml";
352 const char *ProcessGDBRemoteProvider::Info::name = "gdb-remote";
353 const char *VersionProvider::Info::file = "version.txt";
354 const char *VersionProvider::Info::name = "version";
355 const char *WorkingDirectoryProvider::Info::file = "cwd.txt";
356 const char *WorkingDirectoryProvider::Info::name = "cwd";
357