Prevent resumption of the seized process

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

@@ -247,6 +247,12 @@ class ProcessInstanceInfo : public ProcessInfo {
 
   std::optional<bool> IsZombie() const { return m_zombie; }
 
+  void SetNonResumable(bool is_non_resumable) {
+    m_non_resumable = is_non_resumable;
+  }
+
+  std::optional<bool> IsNonResumable() const { return m_non_resumable; }
+
   void Dump(Stream &s, UserIDResolver &resolver) const;
 
   static void DumpTableHeader(Stream &s, bool show_args, bool verbose);
@@ -266,6 +272,7 @@ class ProcessInstanceInfo : public ProcessInfo {
   struct timespec m_cumulative_system_time;
   std::optional<int8_t> m_priority_value = std::nullopt;
   std::optional<bool> m_zombie = std::nullopt;
+  std::optional<bool> m_non_resumable = std::nullopt;
 };
 
 typedef std::vector<ProcessInstanceInfo> ProcessInstanceInfoList;

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

@@ -313,7 +313,8 @@ NativeProcessLinux::Manager::Attach(
   Log *log = GetLog(POSIXLog::Process);
   LLDB_LOG(log, "pid = {0:x}", pid);
 
-  auto tids_or = NativeProcessLinux::Attach(pid);
+  PtraceMethod method = PtraceMethod::Attach;
+  auto tids_or = NativeProcessLinux::Attach(pid, method);
   if (!tids_or)
     return tids_or.takeError();
   ArrayRef<::pid_t> tids = *tids_or;
@@ -322,8 +323,16 @@ NativeProcessLinux::Manager::Attach(
   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->SetNonResumableStop(method == PtraceMethod::Seize);
+
+  return std::move(native_up);
 }
 
 NativeProcessLinux::Extension
@@ -462,12 +471,15 @@ static bool IsCoredumping(lldb::pid_t pid) {
   return result == "1";
 }
 
-llvm::Expected<std::vector<::pid_t>> NativeProcessLinux::Attach(::pid_t pid) {
+llvm::Expected<std::vector<::pid_t>>
+NativeProcessLinux::Attach(::pid_t pid, PtraceMethod &method) {
   Log *log = GetLog(POSIXLog::Process);
 
   bool coreDumping = IsCoredumping(pid);
   LLDB_LOG(log, "{0} coredumping: {1}", pid, coreDumping);
   Status status;
+
+  method = coreDumping ? PtraceMethod::Seize : PtraceMethod::Attach;
   // Use a map to keep track of the threads which we have attached/need to
   // attach.
   Host::TidMap tids_to_attach;
@@ -528,6 +540,11 @@ llvm::Expected<std::vector<::pid_t>> NativeProcessLinux::Attach(::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.
         int wpid =
             llvm::sys::RetryAfterSignal(-1, ::waitpid, tid, nullptr, __WALL);
         // Need to use __WALL otherwise we receive an error with errno=ECHLD At
@@ -2113,3 +2130,11 @@ Expected<std::vector<uint8_t>> NativeProcessLinux::TraceGetBinaryData(
     return m_intel_pt_collector.GetBinaryData(request);
   return NativeProcessProtocol::TraceGetBinaryData(request);
 }
+
+void NativeProcessLinux::SetNonResumableStop(bool value) {
+  m_nonresumable_stop = value;
+}
+
+bool NativeProcessLinux::InNonResumableStop() const {
+  return m_nonresumable_stop;
+}

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

@@ -31,6 +31,12 @@ class Status;
 class Scalar;
 
 namespace process_linux {
+
+// Helper structures to store information about how
+// we attached to a process, whether it was a normal
+// ptrace attach or a special case where we used seize.
+enum PtraceMethod { Attach, Seize };
+
 /// \class NativeProcessLinux
 /// Manages communication with the inferior (debugee) process.
 ///
@@ -164,6 +170,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 SetNonResumableStop(bool value);
+  bool InNonResumableStop() const override;
 
 protected:
   llvm::Expected<llvm::ArrayRef<uint8_t>>
@@ -174,7 +182,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;
 
@@ -189,7 +197,8 @@ class NativeProcessLinux : public NativeProcessELF,
                      llvm::ArrayRef<::pid_t> tids);
 
   // Returns a list of process threads that we have attached to.
-  static llvm::Expected<std::vector<::pid_t>> Attach(::pid_t pid);
+  static llvm::Expected<std::vector<::pid_t>> Attach(::pid_t pid,
+                                                     PtraceMethod &method);
 
   static Status SetDefaultPtraceOpts(const lldb::pid_t);
 

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

@@ -2236,6 +2236,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(1, 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,8 @@ enum GDBRemoteServerError {
   eErrorFirst = 29,
   eErrorNoProcess = eErrorFirst,
   eErrorResume,
-  eErrorExitStatus
+  eErrorExitStatus,
+  eErrorUnresumable
 };
 }
 
@@ -1396,6 +1397,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());
@@ -1676,7 +1681,11 @@ GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_vCont_actions(
     StringExtractorGDBRemote &packet) {
   StreamString response;
-  response.Printf("vCont;c;C;s;S;t");
+  if (m_current_process && m_current_process->CanResume()) {
+    response.Printf("vCont;c;C;s;S;t");
+  } else {
+    response.Printf("vCont");
+  }
 
   return SendPacketNoLock(response.GetString());
 }
@@ -1825,6 +1834,12 @@ GDBRemoteCommunicationServerLLGS::Handle_vCont(
       return SendErrorResponse(GDBRemoteServerError::eErrorResume);
     }
 
+    if (!process_it->second.process_up->CanResume()) {
+      LLDB_LOG(log, "vCont failed for process {0}: process not resumable",
+               x.first);
+      return SendErrorResponse(GDBRemoteServerError::eErrorUnresumable);
+    }
+
     // 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

@@ -1173,6 +1173,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();