When darwin-debug exec's inferior suspended, make debugserver know that suspend count is higher than normal

[jasonmolenda]

Summary

darwin-debug is used to launch a binary while setting the current working directory/env vars/architecture, exec'ing it stopped so lldb can attach to it. This is used on macOS to launch a binary in a new Terminal window via AppleScript. If lldb attaches to the inferior, stopped on the first instruction, all is good. But if lldb attaches before the inferior is running, it will attach to darwin-debug, see the Exec mach exception when the inferior is run, but instead of the normal suspend count of 1 at this point, because darwin-debug asked it to be launch suspended, the suspend count will be 2. debugserver needs to double-resume the inferior to make it run.

This patch adds a specially named segment to darwin-debug so that it can be detected unambiguously by debugserver.

In debugserver, if we attach to a process with the specially named segment, set a flag that will be checked the next time we received an Exec mach exception. When that Exec comes in, set a flag that will be checked the next time we go to resume the inferior to indicate that we need to resume it twice to allow it to run.

[clayborg]

We do have people that don't create debugserver and just use the installed one to avoid code signing. Will there be any issue with people using older debugservers?

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

if (file_conn.Connect(connect_url, &error) == eConnectionStatusSuccess) {
     if (pid_str_len > 0) {
       int pid = atoi(pid_str);
       return (void *)(intptr_t)pid;
     }
   }
   return NULL;
 }
 
-static bool WaitForProcessToSIGSTOP(const lldb::pid_t pid,
-                                    const int timeout_in_seconds) {
-  const int time_delta_usecs = 100000;
-  const int num_retries = timeout_in_seconds / time_delta_usecs;
-  for (int i = 0; i < num_retries; i++) {
-    struct proc_bsdinfo bsd_info;
-    int error = ::proc_pidinfo(pid, PROC_PIDTBSDINFO, (uint64_t)0, &bsd_info,
-                               PROC_PIDTBSDINFO_SIZE);
-
-    switch (error) {
-    case EINVAL:
-    case ENOTSUP:
-    case ESRCH:
-    case EPERM:
-      return false;
-
-    default:
-      break;
-
-    case 0:
-      if (bsd_info.pbi_status == SSTOP)
-        return true;
-    }
-    ::usleep(time_delta_usecs);
-  }
-  return false;
-}
 #if !defined(__arm__) && !defined(__arm64__) && !defined(__aarch64__)
 
 const char *applscript_in_new_tty = "tell application \"Terminal\"\n"
                                     "   activate\n"
                                     "  do script \"/bin/bash -c '%s';exit\"\n"
                                     "end tell\n";
 
 const char *applscript_in_existing_tty = "\
if (!accept_thread)
     return Status(accept_thread.takeError());
 
   [applescript executeAndReturnError:nil];
 
   thread_result_t accept_thread_result = NULL;
   lldb_error = accept_thread->Join(&accept_thread_result);
   if (lldb_error.Success() && accept_thread_result) {
     pid = (intptr_t)accept_thread_result;
-
-    // Wait for process to be stopped at the entry point by watching
-    // for the process status to be set to SSTOP which indicates it it
-    // SIGSTOP'ed at the entry point
-    WaitForProcessToSIGSTOP(pid, 5);
   }
 
   llvm::sys::fs::remove(unix_socket_name);
   [applescript release];
   if (pid != LLDB_INVALID_PROCESS_ID)
     launch_info.SetProcessID(pid);
   return error;
 }

lldb/tools/darwin-debug/CMakeLists.txt

+
+# Create an LC_SEGMENT with the special name ExecExtraSuspend which
+# debugserver can detect - it tells debugserver that it will exec a
+# process and that process will start suspended, so debugserver will
+# need to double-resume it to make it run.  A random file is copied
+# into the segment.
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-sectcreate,ExecExtraSuspend,ExecExtraSuspend,${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt")
+
 add_lldb_tool(darwin-debug ADD_TO_FRAMEWORK
   darwin-debug.cpp
 )

lldb/tools/debugserver/source/MacOSX/MachProcess.mm

if (lc.cmd == LC_SEGMENT) {
       this_seg.vmsize = seg.vmsize;
       this_seg.fileoff = seg.fileoff;
       this_seg.filesize = seg.filesize;
       this_seg.maxprot = seg.maxprot;
       this_seg.initprot = seg.initprot;
       this_seg.nsects = seg.nsects;
       this_seg.flags = seg.flags;
       inf.segments.push_back(this_seg);
+      if (this_seg.name == "ExecExtraSuspend")
+        m_task.TaskWillExecProcessesSuspended();
     }
     if (lc.cmd == LC_SEGMENT_64) {
       struct segment_command_64 seg;
       if (ReadMemory(load_cmds_p, sizeof(struct segment_command_64), &seg) !=
           sizeof(struct segment_command_64)) {
         return false;
       }
       struct mach_o_segment this_seg;
       char name[17];
       ::memset(name, 0, sizeof(name));
       memcpy(name, seg.segname, sizeof(seg.segname));
       this_seg.name = name;
       this_seg.vmaddr = seg.vmaddr;
       this_seg.vmsize = seg.vmsize;
       this_seg.fileoff = seg.fileoff;
       this_seg.filesize = seg.filesize;
       this_seg.maxprot = seg.maxprot;
       this_seg.initprot = seg.initprot;
       this_seg.nsects = seg.nsects;
       this_seg.flags = seg.flags;
       inf.segments.push_back(this_seg);
+      if (this_seg.name == "ExecExtraSuspend")
+        m_task.TaskWillExecProcessesSuspended();
     }
     if (lc.cmd == LC_UUID) {
       struct uuid_command uuidcmd;
       if (ReadMemory(load_cmds_p, sizeof(struct uuid_command), &uuidcmd) ==
           sizeof(struct uuid_command))
         uuid_copy(inf.uuid, uuidcmd.uuid);
     }
 

lldb/tools/debugserver/source/MacOSX/MachTask.h

public:
   static task_t TaskPortForProcessID(pid_t pid, DNBError &err,
                                      uint32_t num_retries = 10,
                                      uint32_t usec_interval = 10000);
 
   MachProcess *Process() { return m_process; }
   const MachProcess *Process() const { return m_process; }
 
   nub_size_t PageSize();
+  void TaskWillExecProcessesSuspended() { m_exec_will_be_suspended = true; }
 
 protected:
   MachProcess *m_process; // The mach process that owns this MachTask
   task_t m_task;
   MachVMMemory m_vm_memory; // Special mach memory reading class that will take
                             // care of watching for page and region boundaries
   MachException::PortInfo
       m_exc_port_info;          // Saved settings for all exception ports
   pthread_t m_exception_thread; // Thread ID for the exception thread in case we
                                 // need it
   mach_port_t m_exception_port; // Exception port on which we will receive child
                                 // exceptions
+  bool m_exec_will_be_suspended; // If this task exec's another process, that
+                                // process will be launched suspended and we will
+                                // need to execute one extra Resume to get it
+                                // to progress from dyld_start.
+  bool m_do_double_resume;      // next time we task_resume(), do it twice to
+                                // fix a too-high suspend count.
 
   typedef std::map<mach_vm_address_t, size_t> allocation_collection;
   allocation_collection m_allocations;
 
 private:
   MachTask(const MachTask &) = delete;
   MachTask &operator=(const MachTask &rhs) = delete;
 };
 
 #endif // __MachTask_h__

lldb/tools/debugserver/source/MacOSX/MachTask.mm

 #include <pmsample.h>
 #endif
 
 //----------------------------------------------------------------------
 // MachTask constructor
 //----------------------------------------------------------------------
 MachTask::MachTask(MachProcess *process)
     : m_process(process), m_task(TASK_NULL), m_vm_memory(),
-      m_exception_thread(0), m_exception_port(MACH_PORT_NULL) {
+      m_exception_thread(0), m_exception_port(MACH_PORT_NULL),
+      m_exec_will_be_suspended(false), m_do_double_resume(false) {
   memset(&m_exc_port_info, 0, sizeof(m_exc_port_info));
 }
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 MachTask::~MachTask() { Clear(); }
 
kern_return_t MachTask::Resume() {
   task_t task = TaskPort();
   if (task == TASK_NULL)
     return KERN_INVALID_ARGUMENT;
 
   DNBError err;
   err = BasicInfo(task, &task_info);
 
   if (err.Success()) {
+    if (m_do_double_resume && task_info.suspend_count == 2) {
+      err = ::task_resume(task);
+      if (DNBLogCheckLogBit(LOG_TASK) || err.Fail())
+        err.LogThreaded("::task_resume double-resume after exec-start-stopped "
+                        "( target_task = 0x%4.4x )", task);
+    }
+    m_do_double_resume = false;
+      
     // task_resume isn't counted like task_suspend calls are, are, so if the
     // task is not suspended, don't try and resume it since it is already
     // running
     if (task_info.suspend_count > 0) {
       err = ::task_resume(task);
       if (DNBLogCheckLogBit(LOG_TASK) || err.Fail())
         err.LogThreaded("::task_resume ( target_task = 0x%4.4x )", task);
     }

 //----------------------------------------------------------------------
 // MachTask::Clear
 //----------------------------------------------------------------------
 void MachTask::Clear() {
   // Do any cleanup needed for this task
   m_task = TASK_NULL;
   m_exception_thread = 0;
   m_exception_port = MACH_PORT_NULL;
+  m_exec_will_be_suspended = false;
+  m_do_double_resume = false;
 }
 
 //----------------------------------------------------------------------
 // MachTask::SaveExceptionPortInfo
 //----------------------------------------------------------------------
 kern_return_t MachTask::SaveExceptionPortInfo() {
   return m_exc_port_info.Save(TaskPort());
 }
kern_return_t MachTask::ShutDownExcecptionThread() {
 
   // Deallocate our exception port that we used to track our child process
   mach_port_t task_self = mach_task_self();
   err = ::mach_port_deallocate(task_self, exception_port);
   if (DNBLogCheckLogBit(LOG_TASK) || err.Fail())
     err.LogThreaded("::mach_port_deallocate ( task = 0x%4.4x, name = 0x%4.4x )",
                     task_self, exception_port);
 
+  m_exec_will_be_suspended = false;
+  m_do_double_resume = false;
+
   return err.Status();
 }
 
 void *MachTask::ExceptionThread(void *arg) {
   if (arg == NULL)
     return NULL;
 
   MachTask *mach_task = (MachTask *)arg;
#define ALWAYS_ZOMBIE_ALLOCATIONS 0
     }
   }
   return false;
 }
 
 void MachTask::TaskPortChanged(task_t task)
 {
   m_task = task;
+
+  // If we've just exec'd to a new process, and it
+  // is started suspended, we'll need to do two
+  // task_resume's to get the inferior process to
+  // continue.
+  if (m_exec_will_be_suspended)
+    m_do_double_resume = true;
+  else
+    m_do_double_resume = false;
+  m_exec_will_be_suspended = false;
 }