[REVERT WHEN 137041 LANDS][GDBServer/PTRACE SEIZE] Implement internal prototype for ptrace seize

Summary:
This is an internal version of my upstream PR [llvm#137041](llvm#137041) where I'm hacking in PTRACE_SEIZE support for Coredumping processes, and then preventing them from being resumed. We only allow exiting, I've explained this in further detail in my test plan.

This is landing internally first, to give the upstream PR and RFC more time to mature and identify problems or new capabilities we could build on top of this workflow.

Test Plan:
The setup to test this is quite convoluted, and I explain in greater detail in my upstream PR, but to summarize here

I compile this program to hold the kernel provided pipe
```
// Set up the corepipe to our program
echo "|/data/users/jalalonde/sand_test_code/ptrace.out %p" | sudo tee /proc/sys/kernel/core_pattern > /dev/null

Invoke the following:
int main() {
  return 42 / 0;
}
```

This will create a program that is coredumping, I've named this sigabrt. We then use pgrep to find our pid.
```
[[email protected] /data/users/jalalonde/sand_test_code]$ pgrep "sigabrt"
3009565
```

And walk through attaching to the coredumping proc, and then trying to continue
```
[[email protected] /data/users/jalalonde/llvm-sand/dbg]$ ./bin/lldb
attach 3009565
Process 3009565 stopped
* thread llvm#1, name = 'sigabrt.out', stop reason = signal SIGSTOP
    frame #0: 0x00005618d35b114d sigabrt.out`main at sigabrt.cpp:6:18
   3    }
Executable binary set to "/data/users/jalalonde/sand_test_code/sigabrt.out".
Architecture set to: x86_64-unknown-linux-gnu.
warning: sigabrt.cpp: source file checksum mismatch between line table (69220de0d0b840cdf9c5b92a82466d5e) and file on disk (f76c8c2b73dc057688650908e7e17f34)
(lldb) bt
* thread llvm#1, name = 'sigabrt.out', stop reason = signal SIGSTOP
  * frame #0: 0x00005618d35b114d sigabrt.out`main at sigabrt.cpp:6:18
    frame llvm#1: 0x00007f0233a295d0 libc.so.6`__libc_start_call_main + 128
    frame llvm#2: 0x00007f0233a29680 libc.so.6`__libc_start_main@@GLIBC_2.34 + 128
    frame llvm#3: 0x00005618d35b1065 sigabrt.out`_start + 37
(lldb) continue
error: Failed to resume process: Process is in a non-resumable stop. Only detach or exit are supported..
(lldb) detach
Process 3009565 detached
```

So we succeeded in attaching, moving from 'S' to trace stop 't' and then preventing resumption would kill the proc, this is crucial so data formatters or other code doesn't accidentally resume and kill the process.

Test Matrix
| Case  | LLDB behavior before patch | LLDB Behavior with patch |
|-------|---------------------------------------------------------
| Attach to Root process | Waitpid hang until ctrl-c | Waitpid hang until ctrl-c |
| Attach to Root process coredumping | Waitpid hanging until ctrl-c | Waitpid hanging until ctrl-c |
| Run Expression | N/A Can't attach | Runs without jitting, no error
| Call function | N/A | Fails gracefully with error

Reviewers: gclayton, wanyi, jeffreytan, peix

Reviewed By: gclayton

Subscribers: davidayoung, peix, #lldb_team

Differential Revision: https://phabricator.intern.facebook.com/D73806555

Author: Jlalond

lldb/include/lldb/Host/common/NativeProcessProtocol.h

@@ -187,7 +187,11 @@ class NativeProcessProtocol {
 
   bool IsStepping() const { return m_state == lldb::eStateStepping; }
 
-  bool CanResume() const { return m_state == lldb::eStateStopped; }
+  bool CanResume() const {
+    return m_state == lldb::eStateStopped && !InNonResumableStop();
+  }
+
+  bool IsStopped() const { return m_state == lldb::eStateStopped; }
 
   lldb::ByteOrder GetByteOrder() const {
     return GetArchitecture().GetByteOrder();
@@ -409,6 +413,16 @@ class NativeProcessProtocol {
                                    "Not implemented");
   }
 
+  /// Check if the process is in a stop that cannot be safely resumed,
+  /// instead only allowing exit of the program.
+  ///
+  /// Some examples are in Linux being PTRACE_O_TRACEEXIT or calling
+  /// PTRACE_SEIZE on a coredumping process.
+  ///
+  /// \return
+  ///   A bool indicating whether this process can ever be resumed.
+  virtual bool InNonResumableStop() const { return false; }
+
 protected:
   struct SoftwareBreakpoint {
     uint32_t ref_count;

lldb/include/lldb/Utility/ProcessInfo.h

@@ -250,7 +250,13 @@ class ProcessInstanceInfo : public ProcessInfo {
   // proc/../status specifies CoreDumping as the field
   // so we match the case here.
   void SetIsCoreDumping(bool is_coredumping) { m_coredumping = is_coredumping; }
-  std::optional<bool> IsCoreDumping() const { return m_coredumping; }
+  bool IsCoreDumping() const { return m_coredumping && *m_coredumping; };
+
+  void SetNonResumable(bool is_nonresumable) {
+    m_non_resumable = is_nonresumable;
+  }
+
+  std::optional<bool> IsNonResumable() const { return m_non_resumable; }
 
   void Dump(Stream &s, UserIDResolver &resolver) const;
 
@@ -272,6 +278,7 @@ class ProcessInstanceInfo : public ProcessInfo {
   std::optional<int8_t> m_priority_value = std::nullopt;
   std::optional<bool> m_zombie = std::nullopt;
   std::optional<bool> m_coredumping = std::nullopt;
+  std::optional<bool> m_non_resumable = std::nullopt;
 };
 
 typedef std::vector<ProcessInstanceInfo> ProcessInstanceInfoList;

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

@@ -312,17 +312,41 @@ NativeProcessLinux::Manager::Attach(
   Log *log = GetLog(POSIXLog::Process);
   LLDB_LOG(log, "pid = {0:x}", pid);
 
-  auto tids_or = NativeProcessLinux::Attach(pid);
-  if (!tids_or)
-    return tids_or.takeError();
-  ArrayRef<::pid_t> tids = *tids_or;
+  // This safety check lets us decide if we should
+  // seize or attach.
+  ProcessInstanceInfo process_info;
+  if (!Host::GetProcessInfo(pid, process_info))
+    return llvm::make_error<StringError>("Unable to read process info",
+                                         llvm::inconvertibleErrorCode());
+
+  std::vector<::pid_t> tids;
+  if (process_info.IsCoreDumping()) {
+    auto attached_or = NativeProcessLinux::Seize(pid);
+    if (!attached_or)
+      return attached_or.takeError();
+    tids = std::move(*attached_or);
+  } else {
+    auto attached_or = NativeProcessLinux::Attach(pid);
+    if (!attached_or)
+      return attached_or.takeError();
+    tids = std::move(*attached_or);
+  }
+
   llvm::Expected<ArchSpec> arch_or =
       NativeRegisterContextLinux::DetermineArchitecture(tids[0]);
   if (!arch_or)
     return arch_or.takeError();
 
-  return std::unique_ptr<NativeProcessLinux>(
+  auto native_up = std::unique_ptr<NativeProcessLinux>(
       new NativeProcessLinux(pid, -1, native_delegate, *arch_or, *this, tids));
+
+  // We currently only seize a process if it's coredumping and thus unresumable.
+  // This is a setter instead of being in the constructor because this could
+  // also be extended in the future to stop the process from being resumed if it
+  // stops for PTRACE_O_TRACEEXIT.
+  native_up->SetInNonResumableStop(process_info.IsCoreDumping());
+
+  return std::move(native_up);
 }
 
 NativeProcessLinux::Extension
@@ -444,6 +468,93 @@ NativeProcessLinux::NativeProcessLinux(::pid_t pid, int terminal_fd,
   SetState(StateType::eStateStopped, false);
 }
 
+llvm::Expected<std::vector<::pid_t>> NativeProcessLinux::Seize(::pid_t pid) {
+  // TODO: Because the Seize during coredumping change introduces the
+  // concept of a non resumable stop, we should also check for
+  // PTRACE_O_TRACEEXIT, which per the man page the status will equal
+  // status >> 8 == (SIGTRAP | (PTRACE_EVENT_EXEC<<8))
+  // and if this is true, we should say we can't resume.
+  Log *log = GetLog(POSIXLog::Process);
+
+  uint64_t options = GetDefaultPtraceOpts();
+  Status status;
+  // Use a map to keep track of the threads which we have attached/need to
+  // attach.
+  Host::TidMap tids_to_attach;
+  while (Host::FindProcessThreads(pid, tids_to_attach)) {
+    for (Host::TidMap::iterator it = tids_to_attach.begin();
+         it != tids_to_attach.end();) {
+      if (it->second == true) {
+        continue;
+      }
+      lldb::tid_t tid = it->first;
+      if ((status = PtraceWrapper(PTRACE_SEIZE, tid, nullptr, (void *)options))
+              .Fail()) {
+        // No such thread. The thread may have exited. More error handling
+        // may be needed.
+        if (status.GetError() == ESRCH) {
+          it = tids_to_attach.erase(it);
+          continue;
+        }
+        if (status.GetError() == EPERM) {
+          // Depending on the value of ptrace_scope, we can return a
+          // different error that suggests how to fix it.
+          return AddPtraceScopeNote(status.ToError());
+        }
+        return status.ToError();
+      }
+
+      if ((status = PtraceWrapper(PTRACE_INTERRUPT, tid)).Fail()) {
+        // No such thread. The thread may have exited. More error handling
+        // may be needed.
+        if (status.GetError() == ESRCH) {
+          it = tids_to_attach.erase(it);
+          continue;
+        }
+        if (status.GetError() == EPERM) {
+          // Depending on the value of ptrace_scope, we can return a
+          // different error that suggests how to fix it.
+          return AddPtraceScopeNote(status.ToError());
+        }
+        return status.ToError();
+      }
+
+      int wpid =
+          llvm::sys::RetryAfterSignal(-1, ::waitpid, tid, nullptr, __WALL);
+      // Need to use __WALL otherwise we receive an error with errno=ECHLD At
+      // this point we should have a thread stopped if waitpid succeeds.
+      if (wpid < 0) {
+        // No such thread. The thread may have exited. More error handling
+        // may be needed.
+        if (errno == ESRCH) {
+          it = tids_to_attach.erase(it);
+          continue;
+        }
+        return llvm::errorCodeToError(
+            std::error_code(errno, std::generic_category()));
+      }
+
+      LLDB_LOG(log, "adding tid = {0}", tid);
+      it->second = true;
+
+      // move the loop forward
+      ++it;
+    }
+  }
+
+  size_t tid_count = tids_to_attach.size();
+  if (tid_count == 0)
+    return llvm::make_error<StringError>("No such process",
+                                         llvm::inconvertibleErrorCode());
+
+  std::vector<::pid_t> tids;
+  tids.reserve(tid_count);
+  for (const auto &p : tids_to_attach)
+    tids.push_back(p.first);
+
+  return std::move(tids);
+}
+
 llvm::Expected<std::vector<::pid_t>> NativeProcessLinux::Attach(::pid_t pid) {
   Log *log = GetLog(POSIXLog::Process);
 
@@ -513,8 +624,8 @@ llvm::Expected<std::vector<::pid_t>> NativeProcessLinux::Attach(::pid_t pid) {
   return std::move(tids);
 }
 
-Status NativeProcessLinux::SetDefaultPtraceOpts(lldb::pid_t pid) {
-  long ptrace_opts = 0;
+uint64_t NativeProcessLinux::GetDefaultPtraceOpts() {
+  uint64_t ptrace_opts = 0;
 
   // Have the child raise an event on exit.  This is used to keep the child in
   // limbo until it is destroyed.
@@ -537,6 +648,11 @@ Status NativeProcessLinux::SetDefaultPtraceOpts(lldb::pid_t pid) {
   // the child finishes sharing memory.
   ptrace_opts |= PTRACE_O_TRACEVFORKDONE;
 
+  return ptrace_opts;
+}
+
+Status NativeProcessLinux::SetDefaultPtraceOpts(lldb::pid_t pid) {
+  uint64_t ptrace_opts = GetDefaultPtraceOpts();
   return PtraceWrapper(PTRACE_SETOPTIONS, pid, nullptr, (void *)ptrace_opts);
 }
 

lldb/source/Plugins/Process/Linux/NativeProcessLinux.h

@@ -165,6 +165,8 @@ class NativeProcessLinux : public NativeProcessELF,
   /// Writes a siginfo_t structure corresponding to the given thread ID to the
   /// memory region pointed to by \p siginfo.
   Status GetSignalInfo(lldb::tid_t tid, void *siginfo) const;
+  void SetInNonResumableStop(bool value) { m_nonresumable_stop = value; }
+  bool InNonResumableStop() const override { return m_nonresumable_stop; }
 
 protected:
   llvm::Expected<llvm::ArrayRef<uint8_t>>
@@ -175,7 +177,7 @@ class NativeProcessLinux : public NativeProcessELF,
 private:
   Manager &m_manager;
   ArchSpec m_arch;
-
+  bool m_nonresumable_stop = false;
   LazyBool m_supports_mem_region = eLazyBoolCalculate;
   std::vector<std::pair<MemoryRegionInfo, FileSpec>> m_mem_region_cache;
 
@@ -191,9 +193,13 @@ class NativeProcessLinux : public NativeProcessELF,
 
   // Returns a list of process threads that we have attached to.
   static llvm::Expected<std::vector<::pid_t>> Attach(::pid_t pid);
+  // Returns a list of process threads that we have seized and interrupted.
+  static llvm::Expected<std::vector<::pid_t>> Seize(::pid_t pid);
 
   static Status SetDefaultPtraceOpts(const lldb::pid_t);
 
+  static uint64_t GetDefaultPtraceOpts();
+
   bool TryHandleWaitStatus(lldb::pid_t pid, WaitStatus status);
 
   void MonitorCallback(NativeThreadLinux &thread, WaitStatus status);

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

@@ -2235,6 +2235,9 @@ bool GDBRemoteCommunicationClient::GetCurrentProcessInfo(bool allow_lazy) {
             if (llvm::to_integer(x, vmaddr, 16))
               m_binary_addresses.push_back(vmaddr);
           }
+        } else if (name == "non_resumable") {
+          if (!value.getAsInteger(0, m_in_nonresumable_stop))
+            ++num_keys_decoded;
         }
       }
       if (num_keys_decoded > 0)

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

@@ -530,6 +530,8 @@ class GDBRemoteCommunicationClient : public GDBRemoteClientBase {
 
   llvm::Expected<int> KillProcess(lldb::pid_t pid);
 
+  bool SafeToResume() const { return !m_in_nonresumable_stop; }
+
 protected:
   LazyBool m_supports_not_sending_acks = eLazyBoolCalculate;
   LazyBool m_supports_thread_suffix = eLazyBoolCalculate;
@@ -622,6 +624,8 @@ class GDBRemoteCommunicationClient : public GDBRemoteClientBase {
   int m_target_vm_page_size = 0; // target system VM page size; 0 unspecified
   uint64_t m_max_packet_size = 0;    // as returned by qSupported
   std::string m_qSupported_response; // the complete response to qSupported
+  bool m_in_nonresumable_stop =
+      false; // true if we are in a stop that cannot be resumed, only exited.
 
   bool m_supported_async_json_packets_is_valid = false;
   lldb_private::StructuredData::ObjectSP m_supported_async_json_packets_sp;

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

@@ -1304,6 +1304,9 @@ void GDBRemoteCommunicationServerCommon::
     if (!abi.empty())
       response.Printf("elf_abi:%s;", abi.c_str());
     response.Printf("ptrsize:%d;", proc_arch.GetAddressByteSize());
+    std::optional<bool> non_resumable = proc_info.IsNonResumable();
+    if (non_resumable)
+      response.Printf("non_resumable:%d;", *non_resumable);
   }
 }
 

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

@@ -62,7 +62,7 @@ enum GDBRemoteServerError {
   eErrorFirst = 29,
   eErrorNoProcess = eErrorFirst,
   eErrorResume,
-  eErrorExitStatus
+  eErrorExitStatus,
 };
 }
 
@@ -1396,6 +1396,10 @@ GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo(
   if (!Host::GetProcessInfo(pid, proc_info))
     return SendErrorResponse(1);
 
+  // We check for the bool so we don't emit the false and waste bytes.
+  if (m_current_process->InNonResumableStop())
+    proc_info.SetNonResumable(true);
+
   StreamString response;
   CreateProcessInfoResponse_DebugServerStyle(proc_info, response);
   return SendPacketNoLock(response.GetString());
@@ -1825,6 +1829,12 @@ GDBRemoteCommunicationServerLLGS::Handle_vCont(
       return SendErrorResponse(GDBRemoteServerError::eErrorResume);
     }
 
+    if (process_it->second.process_up->InNonResumableStop()) {
+      LLDB_LOG(log, "vCont failed for process {0}: process not resumable",
+               x.first);
+      return SendErrorResponse(GDBRemoteServerError::eErrorResume);
+    }
+
     // There are four possible scenarios here.  These are:
     // 1. vCont on a stopped process that resumes at least one thread.
     //    In this case, we call Resume().

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

@@ -966,6 +966,11 @@ void ProcessGDBRemote::DidLaunchOrAttach(ArchSpec &process_arch) {
       // architecture we got from the remote GDB server
       GetTarget().SetArchitecture(process_arch);
     }
+
+    // If the process is in a non resumable stop, we'll keep erroring out
+    // trying to jit and continue the process. So we set can JIT to false
+    // so any expression is evaluated in LLDB.
+    SetCanJIT(m_gdb_comm.SafeToResume());
   }
 
   // Target and Process are reasonably initailized;
@@ -1181,6 +1186,9 @@ void ProcessGDBRemote::DidAttach(ArchSpec &process_arch) {
 }
 
 Status ProcessGDBRemote::WillResume() {
+  if (!m_gdb_comm.SafeToResume())
+    return Status::FromErrorString("Process is in a non-resumable stop. Only "
+                                   "detach or exit are supported");
   m_continue_c_tids.clear();
   m_continue_C_tids.clear();
   m_continue_s_tids.clear();

lldb/unittests/Host/posix/HostTest.cpp

@@ -116,7 +116,6 @@ TEST_F(HostTest, GetProcessInfoSetsPriority) {
   ASSERT_TRUE(Info.IsZombie().has_value());
   ASSERT_FALSE(Info.IsZombie().value());
 
-  ASSERT_TRUE(Info.IsCoreDumping().has_value());
-  ASSERT_FALSE(Info.IsCoreDumping().value());
+  ASSERT_FALSE(Info.IsCoreDumping());
 }
 #endif