[lldb/Reproducers] Fix replay for process attach workflows

[JDevlieghere]

Summary

Support replaying debug sessions that attach to an existing process instead of lldb launching the inferior. Bypass the logic that looks for a process with the given name and use an arbitrary PID. The value of the PID doesn't matter as the gdb remote replay infrastructure intercepts the attach and pretends that we're connected to the original process.

[labath]

A more principled way to make this work would be to intercept (record) the Host::FindProcesses api. That way other functionality pertaining to running processes (e.g. the "platform process list" command) would also work. But if this is all you care about right now, then maybe this is fine...

The part that worries me more is the test. There are a lot of subtleties involved in making attach tests (and attach-by-name tests in particular) work reliably everywhere. I think this should be a dotest test, as there we already have some machinery to do these kinds of things (lldb_enable_attach, wait_for_file_on_target), and python is generally much better at complex control flow (I am very much against subshells and background processes in lit tests). Reproducers make this somewhat complicated because you cannot use the liblldb instance already loaded into the python process. But maybe you could run lldb in a subprocess similar to how the pexpect tests do it?

lldb/test/Shell/Reproducer/Inputs/sleep.c

5 ↗

(On Diff #249226)

For attach to work reliably on linux, you need to ensure the process declares itself willing to be attached to. This is what the lldb_enable_attach macro in dotest inferiors does. Then you also need to ensure that the process has executed that statement before you attempt to attach. This is usually done via some pid file synchronization.

lldb/test/Shell/Reproducer/TestAttach.test

7 ↗

(On Diff #249226)

How is this different from a plain %t/attach.out & ?

9 ↗

(On Diff #249226)

Though normally determinism is good, in this case I think it is actually better to generate an unpredictable name for the process to avoid having the test be impacted by parallel test suite runs or leftover zombies. Other attach-by-name tests usually embed some a pid or a timestamp into the process name.

[JDevlieghere]

In D75877#1913959, @labath wrote:

A more principled way to make this work would be to intercept (record) the Host::FindProcesses api. That way other functionality pertaining to running processes (e.g. the "platform process list" command) would also work. But if this is all you care about right now, then maybe this is fine...

We could totally add a provider for that. I didn't because it seemed like overkill but if you're on board I also prefer that over a random PID.

The part that worries me more is the test. There are a lot of subtleties involved in making attach tests (and attach-by-name tests in particular) work reliably everywhere. I think this should be a dotest test, as there we already have some machinery to do these kinds of things (lldb_enable_attach, wait_for_file_on_target), and python is generally much better at complex control flow (I am very much against subshells and background processes in lit tests). Reproducers make this somewhat complicated because you cannot use the liblldb instance already loaded into the python process. But maybe you could run lldb in a subprocess similar to how the pexpect tests do it?

The problem is the SBDebugger::Initialize() that's called from the SWIG bindings, as soon as you import lldb it's already too late for the reproducers. I'm working on being able to capture/replay the test suite and currently I have the following hack:

if 'DOTEST_CAPTURE_PATH' in os.environ:
   SBReproducer.Capture(os.environ['DOTEST_CAPTURE_PATH'])
SBDebugger.Initialize()

If you're fine with having that in python.swig unconditionally we could make a dotest-test work.

lldb/test/Shell/Reproducer/TestAttach.test

7 ↗

(On Diff #249226)

Should that work? That's the first thing I tried and lit complained about invalid syntax.

[labath]

In D75877#1914755, @JDevlieghere wrote:

In D75877#1913959, @labath wrote:

A more principled way to make this work would be to intercept (record) the Host::FindProcesses api. That way other functionality pertaining to running processes (e.g. the "platform process list" command) would also work. But if this is all you care about right now, then maybe this is fine...

We could totally add a provider for that. I didn't because it seemed like overkill but if you're on board I also prefer that over a random PID.

In general, I am in favor of doing the capture at the lowest level possible. For this particular feature/bug, it is overkill, but OTOH, this will also make it possible to support things other things without adding hacks into random pieces of code.

The part that worries me more is the test. There are a lot of subtleties involved in making attach tests (and attach-by-name tests in particular) work reliably everywhere. I think this should be a dotest test, as there we already have some machinery to do these kinds of things (lldb_enable_attach, wait_for_file_on_target), and python is generally much better at complex control flow (I am very much against subshells and background processes in lit tests). Reproducers make this somewhat complicated because you cannot use the liblldb instance already loaded into the python process. But maybe you could run lldb in a subprocess similar to how the pexpect tests do it?

The problem is the SBDebugger::Initialize() that's called from the SWIG bindings, as soon as you import lldb it's already too late for the reproducers. I'm working on being able to capture/replay the test suite and currently I have the following hack:

if 'DOTEST_CAPTURE_PATH' in os.environ:
   SBReproducer.Capture(os.environ['DOTEST_CAPTURE_PATH'])
SBDebugger.Initialize()

If you're fine with having that in python.swig unconditionally we could make a dotest-test work.

I'm not sure how that would help because for the test you need to run lldb both in capture and replay mode, and I don't think you can currently do that within a single process. It would be cool if that was possible, but even then we'd have the impendance mismatch because we'd need to run SBDebugger.Initialize inside a specific test method, whereas normally it gets run much earlier.

That's why I was talking about subprocesses in the previous patch. The test would only be responsible for building the inferior and driving the whole thing, while capture/replay would happen inside separate processes:

self.spawnSubproces(randomized_inferior_name, [token_path])
lldbutil.wait_for_file_on_target(token_path)
self.spawnSubprocess(lldbtest_config.lldbExec, ['--capture', reproducer, '-n', randomized_inferior_name, ...])
...
self.spawnSubprocess(lldbtest_config.lldbExec, ['--replay', reproducer])

lldb/test/Shell/Reproducer/TestAttach.test

7 ↗

(On Diff #249226)

I've seen tests do that (RUN: setsid %run %t/LFSIGUSR -merge=1 -merge_control_file=%t/MCF %t/C1 %t/C2 2>%t/log & export PID=$! in ./compiler-rt/test/fuzzer/merge-sigusr.test), but as I said, I don't think that is a good idea, so I don't really want to encourange it...

[JDevlieghere]

In D75877#1914900, @labath wrote:

In D75877#1914755, @JDevlieghere wrote:

In D75877#1913959, @labath wrote:

A more principled way to make this work would be to intercept (record) the Host::FindProcesses api. That way other functionality pertaining to running processes (e.g. the "platform process list" command) would also work. But if this is all you care about right now, then maybe this is fine...

We could totally add a provider for that. I didn't because it seemed like overkill but if you're on board I also prefer that over a random PID.

In general, I am in favor of doing the capture at the lowest level possible. For this particular feature/bug, it is overkill, but OTOH, this will also make it possible to support things other things without adding hacks into random pieces of code.

The part that worries me more is the test. There are a lot of subtleties involved in making attach tests (and attach-by-name tests in particular) work reliably everywhere. I think this should be a dotest test, as there we already have some machinery to do these kinds of things (lldb_enable_attach, wait_for_file_on_target), and python is generally much better at complex control flow (I am very much against subshells and background processes in lit tests). Reproducers make this somewhat complicated because you cannot use the liblldb instance already loaded into the python process. But maybe you could run lldb in a subprocess similar to how the pexpect tests do it?

The problem is the SBDebugger::Initialize() that's called from the SWIG bindings, as soon as you import lldb it's already too late for the reproducers. I'm working on being able to capture/replay the test suite and currently I have the following hack:

if 'DOTEST_CAPTURE_PATH' in os.environ:
   SBReproducer.Capture(os.environ['DOTEST_CAPTURE_PATH'])
SBDebugger.Initialize()

If you're fine with having that in python.swig unconditionally we could make a dotest-test work.

I'm not sure how that would help because for the test you need to run lldb both in capture and replay mode, and I don't think you can currently do that within a single process. It would be cool if that was possible, but even then we'd have the impendance mismatch because we'd need to run SBDebugger.Initialize inside a specific test method, whereas normally it gets run much earlier.

That's why I was talking about subprocesses in the previous patch. The test would only be responsible for building the inferior and driving the whole thing, while capture/replay would happen inside separate processes:

Ah, I misunderstood subprocess as another Python process, yeah launching the driver should work. Thanks for the clarification.

[JDevlieghere]

• Add ProcessInfo provider.
• Rewrite test as an dotest-test.

[labath]

A bunch of comments but nothing really major. Maybe it would be nice to put the code for yamlification of ProcessInfo into a separate patch?

lldb/source/Commands/CommandObjectReproducer.cpp

542–555

Maybe some kind of a utility function to convert a file to an object?
template<typename T> Expected<T> readAsYaml(StringRef filename) ?

lldb/source/Host/macosx/objcxx/Host.mm

595

This means that every implementation of FindProcesses will need to introduce this bolierplate. We should put this into common code somehow. One way to do that would be to rename all the platform-specific implementations to something like DoFindProcesses, and then implement FindProcesses source/Host/common/Host.cpp to handle the delegation & reproducer logic.

lldb/source/Utility/FileSpec.cpp

543 ↗

(On Diff #249555)

There's more to FileSpecs than just the path -- they also hold the path syntax and the "case-sensitive" bit. Kind of not needed for your current goal, but maybe we should add those too while we're here?

lldb/source/Utility/ProcessInfo.cpp

400–403

You don't actually have to provide these functions if they are not going to do anything.

417–430

random thought: Would any of this be simpler if this wasn't a "multi" provider but rather stored all of the responses as a sequence in a single file?

436

what's the type of this?

lldb/test/API/functionalities/reproducers/attach/TestReproducerAttach.py

31

You still need to do the wait_for_file_on_target dance here to ensure that lldb_enable_attach is executed before we actually attach. One example of that is in test/API/python_api/hello_world/main.c.

lldb/test/API/functionalities/reproducers/attach/main.cpp

11

You probably copied this from some existing test, but I'd say this is putting unnecessary load on the system. For this use case even a 1-second sleep would be perfectly fine.

[JDevlieghere]

Address code review feedback.

[JDevlieghere]

lldb/source/Utility/ProcessInfo.cpp

417–430

Maybe/Probably? I'm not sure. But even if it were a bit simpler, I think it's better to reuse the existing multi-provider for consistency.

[labath]

lldb/test/API/functionalities/reproducers/attach/TestReproducerAttach.py

36

s/patch/path

54–55

self.assertIn(needle, haystack)

67–76

Would it be possible to run this in the context of the current process (via self.expect?)

75–76

I guess you meant assertIn here too

78–83

The reproducer dir will still linger on if the test fails for any reason. If you just put this in the build directory (by (ab)using self.getBuildArtifact), then maybe you don't need to clean it up, as it will be automatically deleted the next time the test suite runs...

lldb/include/lldb/Host/Host.h

public:
 
   static bool OpenFileInExternalEditor(const FileSpec &file_spec,
                                        uint32_t line_no);
 
   static Environment GetEnvironment();
 
   static std::unique_ptr<Connection>
   CreateDefaultConnection(llvm::StringRef url);
+
+protected:
+  static uint32_t FindProcessesImpl(const ProcessInstanceInfoMatch &match_info,
+                                    ProcessInstanceInfoList &proc_infos);
 };
 
 } // namespace lldb_private
 
 namespace llvm {
 template <> struct format_provider<lldb_private::WaitStatus> {
   /// Options = "" gives a human readable description of the status Options =
   /// "g" gives a gdb-remote protocol status (e.g., X09)
   static void format(const lldb_private::WaitStatus &WS, raw_ostream &OS,
                      llvm::StringRef Options);
 };
 } // namespace llvm
 
 #endif // LLDB_HOST_HOST_H

lldb/include/lldb/Utility/ProcessInfo.h

 //===-- ProcessInfo.h -------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_UTILITY_PROCESSINFO_H
 #define LLDB_UTILITY_PROCESSINFO_H
 
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Environment.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/NameMatches.h"
+#include "lldb/Utility/Reproducer.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <vector>
 
 namespace lldb_private {
 
 class UserIDResolver;
 
 // ProcessInfo
public:
   void Clear();
 
 protected:
   ProcessInstanceInfo m_match_info;
   NameMatch m_name_match_type;
   bool m_match_all_users;
 };
 
+namespace repro {
+class ProcessInfoRecorder : public AbstractRecorder {
+public:
+  ProcessInfoRecorder(const FileSpec &filename, std::error_code &ec)
+      : AbstractRecorder(filename, ec) {}
+
+  static llvm::Expected<std::unique_ptr<ProcessInfoRecorder>>
+  Create(const FileSpec &filename);
+
+  void Record(const ProcessInstanceInfoList &process_infos);
+};
+
+class ProcessInfoProvider : public repro::Provider<ProcessInfoProvider> {
+public:
+  struct Info {
+    static const char *name;
+    static const char *file;
+  };
+
+  ProcessInfoProvider(const FileSpec &directory) : Provider(directory) {}
+
+  ProcessInfoRecorder *GetNewProcessInfoRecorder();
+
+  void Keep() override;
+  void Discard() override;
+
+  static char ID;
+
+private:
+  std::unique_ptr<llvm::raw_fd_ostream> m_stream_up;
+  std::vector<std::unique_ptr<ProcessInfoRecorder>> m_process_info_recorders;
+};
+
+llvm::Optional<ProcessInstanceInfoList> GetReplayProcessInstanceInfoList();
+
+} // namespace repro
 } // namespace lldb_private
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(lldb_private::ProcessInstanceInfo)
 
 namespace llvm {
 namespace yaml {
 template <> struct MappingTraits<lldb_private::ProcessInstanceInfo> {
   static void mapping(IO &io, lldb_private::ProcessInstanceInfo &PII);
 };
 } // namespace yaml
 } // namespace llvm
 
 #endif // LLDB_UTILITY_PROCESSINFO_H

lldb/source/Commands/CommandObjectReproducer.cpp

 //===-- CommandObjectReproducer.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "CommandObjectReproducer.h"
 
+#include "lldb/Host/HostInfo.h"
 #include "lldb/Host/OptionParser.h"
-#include "lldb/Utility/GDBRemote.h"
-#include "lldb/Utility/Reproducer.h"
-
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
+#include "lldb/Utility/GDBRemote.h"
+#include "lldb/Utility/ProcessInfo.h"
+#include "lldb/Utility/Reproducer.h"
 
 #include <csignal>
 
 using namespace lldb;
 using namespace llvm;
 using namespace lldb_private;
 using namespace lldb_private::repro;
 
 enum ReproducerProvider {
   eReproducerProviderCommands,
   eReproducerProviderFiles,
   eReproducerProviderGDB,
+  eReproducerProviderProcessInfo,
   eReproducerProviderVersion,
   eReproducerProviderWorkingDirectory,
   eReproducerProviderNone
 };
 
 static constexpr OptionEnumValueElement g_reproducer_provider_type[] = {
     {
         eReproducerProviderCommands,
         "commands",
         "Command Interpreter Commands",
     },
     {
         eReproducerProviderFiles,
         "files",
         "Files",
     },
     {
         eReproducerProviderGDB,
         "gdb",
         "GDB Remote Packets",
     },
     {
+        eReproducerProviderProcessInfo,
+        "processes",
+        "Process Info",
+    },
+    {
         eReproducerProviderVersion,
         "version",
         "Version",
     },
     {
         eReproducerProviderWorkingDirectory,
         "cwd",
         "Working Directory",

 
 static constexpr OptionEnumValues ReproducerSignalType() {
   return OptionEnumValues(g_reproducer_signaltype);
 }
 
 #define LLDB_OPTIONS_reproducer_xcrash
 #include "CommandOptions.inc"
 
+template <typename T>
+llvm::Expected<T> static ReadFromYAML(StringRef filename) {
+  auto error_or_file = MemoryBuffer::getFile(filename);
+  if (auto err = error_or_file.getError()) {
+    return errorCodeToError(err);
+  }
+
+  T t;
+  yaml::Input yin((*error_or_file)->getBuffer());
+  yin >> t;
+
+  if (auto err = yin.error()) {
+    return errorCodeToError(err);
+  }
+
+  return t;
+}
+
 class CommandObjectReproducerGenerate : public CommandObjectParsed {
 public:
   CommandObjectReproducerGenerate(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "reproducer generate",
             "Generate reproducer on disk. When the debugger is in capture "
             "mode, this command will output the reproducer to a directory on "
             "disk and quit. In replay mode this command in a no-op.",
case eReproducerProviderGDB: {
         SetError(result,
                  make_error<StringError>("Unable to create GDB loader.",
                                          llvm::inconvertibleErrorCode()));
         return false;
       }
 
       llvm::Optional<std::string> gdb_file;
       while ((gdb_file = multi_loader->GetNextFile())) {
-        auto error_or_file = MemoryBuffer::getFile(*gdb_file);
-        if (auto err = error_or_file.getError()) {
-          SetError(result, errorCodeToError(err));
+        if (llvm::Expected<std::vector<GDBRemotePacket>> packets =
+                ReadFromYAML<std::vector<GDBRemotePacket>>(*gdb_file)) {
+          for (GDBRemotePacket &packet : *packets) {
+            packet.Dump(result.GetOutputStream());
+          }
+        } else {
+          SetError(result, packets.takeError());
           return false;
         }
+      }
 
-        std::vector<GDBRemotePacket> packets;
-        yaml::Input yin((*error_or_file)->getBuffer());
-        yin >> packets;
+      result.SetStatus(eReturnStatusSuccessFinishResult);
+      return true;
+    }
+    case eReproducerProviderProcessInfo: {
+      std::unique_ptr<repro::MultiLoader<repro::ProcessInfoProvider>>
+          multi_loader =
+              repro::MultiLoader<repro::ProcessInfoProvider>::Create(loader);
 
-        if (auto err = yin.error()) {
-          SetError(result, errorCodeToError(err));
-          return false;
-        }
+      if (!multi_loader) {
+        SetError(result, make_error<StringError>(
+                             llvm::inconvertibleErrorCode(),
+                             "Unable to create process info loader."));
 
-        for (GDBRemotePacket &packet : packets) {
-          packet.Dump(result.GetOutputStream());
+      llvm::Optional<std::string> process_file;
+      while ((process_file = multi_loader->GetNextFile())) {
+        if (llvm::Expected<ProcessInstanceInfoList> infos =
+                ReadFromYAML<ProcessInstanceInfoList>(*process_file)) {
+          for (ProcessInstanceInfo info : *infos)
+            info.Dump(result.GetOutputStream(), HostInfo::GetUserIDResolver());
+        } else {
+          SetError(result, infos.takeError());
+          return false;
         }
       }
 
       result.SetStatus(eReturnStatusSuccessFinishResult);
       return true;
     }
     case eReproducerProviderNone:
       result.SetError("No valid provider specified.");
       return false;
     }
 
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
 };
 
 CommandObjectReproducer::CommandObjectReproducer(
     CommandInterpreter &interpreter)
     : CommandObjectMultiword(
           interpreter, "reproducer",
           "Commands for manipulating reproducers. Reproducers make it "
           "possible "
           "to capture full debug sessions with all its dependencies. The "
           "resulting reproducer is used to replay the debug session while "
           "debugging the debugger.\n"
           "Because reproducers need the whole the debug session from "
           "beginning to end, you need to launch the debugger in capture or "
           "replay mode, commonly though the command line driver.\n"
           "Reproducers are unrelated record-replay debugging, as you cannot "
           "interact with the debugger during replay.\n",
           "reproducer <subcommand> [<subcommand-options>]") {
   LoadSubCommand(
       "generate",
       CommandObjectSP(new CommandObjectReproducerGenerate(interpreter)));
   LoadSubCommand("status", CommandObjectSP(
                                new CommandObjectReproducerStatus(interpreter)));
   LoadSubCommand("dump",
                  CommandObjectSP(new CommandObjectReproducerDump(interpreter)));
   LoadSubCommand("xcrash", CommandObjectSP(
                                new CommandObjectReproducerXCrash(interpreter)));
 }
 
 CommandObjectReproducer::~CommandObjectReproducer() = default;

lldb/source/Host/common/Host.cpp

case WaitStatus::Signal:
     desc = "Killed by signal";
     break;
   case WaitStatus::Stop:
     desc = "Stopped by signal";
     break;
   }
   OS << desc << " " << int(WS.status);
 }
+
+uint32_t Host::FindProcesses(const ProcessInstanceInfoMatch &match_info,
+                             ProcessInstanceInfoList &process_infos) {
+
+  if (llvm::Optional<ProcessInstanceInfoList> infos =
+          repro::GetReplayProcessInstanceInfoList()) {
+    process_infos = *infos;
+    return process_infos.size();
+  }
+
+  uint32_t result = FindProcessesImpl(match_info, process_infos);
+
+  if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator()) {
+    g->GetOrCreate<repro::ProcessInfoProvider>()
+        .GetNewProcessInfoRecorder()
+        ->Record(process_infos);
+  }
+
+  return result;
+}

lldb/source/Host/linux/Host.cpp

static bool GetProcessAndStatInfo(::pid_t pid,
 
   // Get User and Group IDs and get tracer pid.
   if (!GetStatusInfo(pid, process_info, State, tracerpid))
     return false;
 
   return true;
 }
 
-uint32_t Host::FindProcesses(const ProcessInstanceInfoMatch &match_info,
+uint32_t Host::FindProcessesImpl(const ProcessInstanceInfoMatch &match_info,
                                  ProcessInstanceInfoList &process_infos) {
   static const char procdir[] = "/proc/";
 
   DIR *dirproc = opendir(procdir);
   if (dirproc) {
     struct dirent *direntry = nullptr;
     const uid_t our_uid = getuid();
     const lldb::pid_t our_pid = getpid();
     bool all_users = match_info.GetMatchAllUsers();

lldb/source/Host/macosx/objcxx/Host.mm

static bool GetMacOSXProcessUserAndGroup(ProcessInstanceInfo &process_info) {
   process_info.SetParentProcessID(LLDB_INVALID_PROCESS_ID);
   process_info.SetUserID(UINT32_MAX);
   process_info.SetGroupID(UINT32_MAX);
   process_info.SetEffectiveUserID(UINT32_MAX);
   process_info.SetEffectiveGroupID(UINT32_MAX);
   return false;
 }
 
-uint32_t Host::FindProcesses(const ProcessInstanceInfoMatch &match_info,
+uint32_t Host::FindProcessesImpl(const ProcessInstanceInfoMatch &match_info,
                                  ProcessInstanceInfoList &process_infos) {
   std::vector<struct kinfo_proc> kinfos;
 
   int mib[3] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL};
 
   size_t pid_data_size = 0;
   if (::sysctl(mib, 3, nullptr, &pid_data_size, nullptr, 0) != 0)
     return 0;
 

lldb/source/Host/netbsd/Host.cpp

error:
   process_info.SetParentProcessID(LLDB_INVALID_PROCESS_ID);
   process_info.SetUserID(UINT32_MAX);
   process_info.SetGroupID(UINT32_MAX);
   process_info.SetEffectiveUserID(UINT32_MAX);
   process_info.SetEffectiveGroupID(UINT32_MAX);
   return false;
 }
 
-uint32_t Host::FindProcesses(const ProcessInstanceInfoMatch &match_info,
+uint32_t Host::FindProcessesImpl(const ProcessInstanceInfoMatch &match_info,
                                  ProcessInstanceInfoList &process_infos) {
   const ::pid_t our_pid = ::getpid();
   const ::uid_t our_uid = ::getuid();
 
   const bool all_users =
       match_info.GetMatchAllUsers() ||
       // Special case, if lldb is being run as root we can attach to anything
       (our_uid == 0);
 

lldb/source/Host/openbsd/Host.cpp

static bool GetOpenBSDProcessUserAndGroup(ProcessInstanceInfo &process_info) {
   process_info.SetParentProcessID(LLDB_INVALID_PROCESS_ID);
   process_info.SetUserID(UINT32_MAX);
   process_info.SetGroupID(UINT32_MAX);
   process_info.SetEffectiveUserID(UINT32_MAX);
   process_info.SetEffectiveGroupID(UINT32_MAX);
   return false;
 }
 
-uint32_t Host::FindProcesses(const ProcessInstanceInfoMatch &match_info,
+uint32_t Host::FindProcessesImpl(const ProcessInstanceInfoMatch &match_info,
                                  ProcessInstanceInfoList &process_infos) {
   std::vector<struct kinfo_proc> kinfos;
 
   int mib[3] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL};
 
   size_t pid_data_size = 0;
   if (::sysctl(mib, 3, NULL, &pid_data_size, NULL, 0) != 0)
     return 0;
 

lldb/source/Utility/ProcessInfo.cpp

 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/UserIDResolver.h"
 #include "llvm/ADT/SmallString.h"
 
 #include <climits>
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::repro;
 
 ProcessInfo::ProcessInfo()
     : m_executable(), m_arguments(), m_environment(), m_uid(UINT32_MAX),
       m_gid(UINT32_MAX), m_arch(), m_pid(LLDB_INVALID_PROCESS_ID) {}
 
 ProcessInfo::ProcessInfo(const char *name, const ArchSpec &arch,
                          lldb::pid_t pid)
     : m_executable(name), m_arguments(), m_environment(), m_uid(UINT32_MAX),
void llvm::yaml::MappingTraits<ProcessInstanceInfo>::mapping(
   io.mapRequired("arch", Info.m_arch);
   io.mapRequired("uid", Info.m_uid);
   io.mapRequired("gid", Info.m_gid);
   io.mapRequired("pid", Info.m_pid);
   io.mapRequired("effective-uid", Info.m_euid);
   io.mapRequired("effective-gid", Info.m_egid);
   io.mapRequired("parent-pid", Info.m_parent_pid);
 }
+
+llvm::Expected<std::unique_ptr<ProcessInfoRecorder>>
+ProcessInfoRecorder::Create(const FileSpec &filename) {
+  std::error_code ec;
+  auto recorder =
+      std::make_unique<ProcessInfoRecorder>(std::move(filename), ec);
+  if (ec)
+    return llvm::errorCodeToError(ec);
+  return std::move(recorder);
+}
+
+void ProcessInfoProvider::Keep() {
+  std::vector<std::string> files;
+  for (auto &recorder : m_process_info_recorders) {
+    recorder->Stop();
+    files.push_back(recorder->GetFilename().GetPath());
+  }
+
+  FileSpec file = GetRoot().CopyByAppendingPathComponent(Info::file);
+  std::error_code ec;
+  llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_Text);
+  if (ec)
+    return;
+  llvm::yaml::Output yout(os);
+  yout << files;
+}
+
+void ProcessInfoProvider::Discard() { m_process_info_recorders.clear(); }
+
+ProcessInfoRecorder *ProcessInfoProvider::GetNewProcessInfoRecorder() {
+  std::size_t i = m_process_info_recorders.size() + 1;
+  std::string filename = (llvm::Twine(Info::name) + llvm::Twine("-") +
+                          llvm::Twine(i) + llvm::Twine(".yaml"))
+                             .str();
+  auto recorder_or_error = ProcessInfoRecorder::Create(
+      GetRoot().CopyByAppendingPathComponent(filename));
+  if (!recorder_or_error) {
+    llvm::consumeError(recorder_or_error.takeError());
+    return nullptr;
+  }
+
+  m_process_info_recorders.push_back(std::move(*recorder_or_error));
+  return m_process_info_recorders.back().get();
+}
+
+void ProcessInfoRecorder::Record(const ProcessInstanceInfoList &process_infos) {
+  if (!m_record)
+    return;
+  llvm::yaml::Output yout(m_os);
+  yout << const_cast<ProcessInstanceInfoList &>(process_infos);
+  m_os.flush();
+}
+
+llvm::Optional<ProcessInstanceInfoList>
+repro::GetReplayProcessInstanceInfoList() {
+  static std::unique_ptr<repro::MultiLoader<repro::ProcessInfoProvider>>
+      loader = repro::MultiLoader<repro::ProcessInfoProvider>::Create(
+          repro::Reproducer::Instance().GetLoader());
+
+  if (!loader)
+    return {};
+
+  llvm::Optional<std::string> nextfile = loader->GetNextFile();
+  if (!nextfile)
+    return {};
+
+  auto error_or_file = llvm::MemoryBuffer::getFile(*nextfile);
+  if (std::error_code err = error_or_file.getError())
+    return {};
+
+  ProcessInstanceInfoList infos;
+  llvm::yaml::Input yin((*error_or_file)->getBuffer());
+  yin >> infos;
+
+  if (auto err = yin.error())
+    return {};
+
+  return infos;
+}
+
+char ProcessInfoProvider::ID = 0;
+const char *ProcessInfoProvider::Info::file = "process-info.yaml";
+const char *ProcessInfoProvider::Info::name = "process-info";

lldb/test/API/functionalities/reproducers/attach/Makefile

+CXX_SOURCES := main.cpp
+include Makefile.rules

lldb/test/API/functionalities/reproducers/attach/TestReproducerAttach.py

+"""
+Test reproducer attach.
+"""
+
+import lldb
+import tempfile
+from lldbsuite.test import lldbtest_config
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class CreateAfterAttachTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
+
+    @skipIfFreeBSD
+    @skipIfNetBSD
+    @skipIfWindows
+    @skipIfRemote
+    @skipIfiOSSimulator
+    def test_create_after_attach_with_fork(self):
+        """Test thread creation after process attach."""
+        exe = '%s_%d' % (self.testMethodName, os.getpid())
+
+        token = self.getBuildArtifact(exe + '.token')
+        if os.path.exists(token):
+            os.remove(token)
+
+        reproducer = self.getBuildArtifact(exe + '.reproducer')
+        if os.path.exists(reproducer):
+            try:
+                shutil.rmtree(reproducer)
+            except OSError:
+                pass
+
+        self.build(dictionary={'EXE': exe})
+        self.addTearDownHook(self.cleanupSubprocesses)
+
+        inferior = self.spawnSubprocess(self.getBuildArtifact(exe), [token])
+        pid = inferior.pid
+
+        lldbutil.wait_for_file_on_target(self, token)
+
+        # Use Popen because pexpect is overkill and spawnSubprocess is
+        # asynchronous.
+        capture = subprocess.Popen([
+            lldbtest_config.lldbExec, '-b', '--capture', '--capture-path',
+            reproducer, '-o', 'proc att -n {}'.format(exe), '-o',
+            'reproducer generate'
+        ],
+                                   stdin=subprocess.PIPE,
+                                   stdout=subprocess.PIPE,
+                                   stderr=subprocess.PIPE)
+        outs, errs = capture.communicate()
+        self.assertIn('Process {} stopped'.format(pid), outs)
+        self.assertIn('Reproducer written', outs)
+
+        # Check that replay works.
+        replay = subprocess.Popen(
+            [lldbtest_config.lldbExec, '-replay', reproducer],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE)
+        outs, errs = replay.communicate()
+        self.assertIn('Process {} stopped'.format(pid), outs)
+
+        # We can dump the reproducer in the current context.
+        self.expect('reproducer dump -f {} -p process'.format(reproducer),
+                    substrs=['pid = {}'.format(pid), 'name = {}'.format(exe)])

lldb/test/API/functionalities/reproducers/attach/main.cpp

+#include <chrono>
+#include <stdio.h>
+#include <thread>
+
+using std::chrono::seconds;
+
+int main(int argc, char const *argv[]) {
+  lldb_enable_attach();
+
+  // Create the synchronization token.
+  FILE *f;
+  if (f = fopen(argv[1], "wx")) {
+    fputs("\n", f);
+    fflush(f);
+    fclose(f);
+  } else
+    return 1;
+
+  while (true) {
+    std::this_thread::sleep_for(seconds(1));
+  }
+
+  return 0;
+}