[LLGS] Spawned process handling cleanup

[labath]

Summary

This commit moves the m_spawned_pids member from the common LLGS/Platform class to the plaform
specific part. This enables us to remove LLGS code, which was attempting to manage the
m_spawned_pids contents, but at the same time making sure, there is only one debugged process. If
we ever want to do multi-process debugging, we will probably want to replace this with a set of
NativeProcessProtocolSP anyway. The only functional change is that support for
qKillSpawnedProcess packet is removed from LLGS, but this was not used there anyway (we have the
k packet for that).

[ovyalov]

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

280

We may want to check for GetID() != LLDB_INVALID_PROCESS_ID becauseNativeProcessProtocol::Attach doesn't nullify native_process_sp if AttachToInferior fails.

Considering how often we check something like m_debugged_process_sp && (m_debugged_process_sp->GetID () != LLDB_INVALID_PROCESS_ID)" having a separate method for this might be pretty convenient - we can do it in another CL.

299–300

return Error(...)?

[clayborg]

Fix the m_debugged_process_sp check and this is good to go.

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

280

Or put ask the process to validate itself with IsBeingDebugged() or some other function that verifies the process is being debugged:

if (m_debugged_process_sp && m_debugged_process_sp->IsBeingDebugged())

[labath]

• Add a check for process validity

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

280

I have added a check for LLDB_INVALID_PROCESS_ID. For the future I would like to clean this up more so that m_debugged_process_sp is non-null if and only if we have a valid debugged process.

[clayborg]

Looks good as long as the process ID is set to invalid when the process exits?

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.h

 //===-- GDBRemoteCommunicationServerCommon.h --------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_GDBRemoteCommunicationServerCommon_h_
 #define liblldb_GDBRemoteCommunicationServerCommon_h_
 
 // C Includes
 // C++ Includes
-#include <set>
 
 // Other libraries and framework includes
 #include "lldb/lldb-private-forward.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Target/Process.h"
 
 // Project includes
 #include "GDBRemoteCommunicationServer.h"

 {
 public:
     GDBRemoteCommunicationServerCommon(const char *comm_name, const char *listener_name);
 
     virtual
     ~GDBRemoteCommunicationServerCommon();
 
 protected:
-    std::set<lldb::pid_t> m_spawned_pids;
-    Mutex m_spawned_pids_mutex;
     ProcessLaunchInfo m_process_launch_info;
     Error m_process_launch_error;
     ProcessInstanceInfoList m_proc_infos;
     uint32_t m_proc_infos_index;
     bool m_thread_suffix_supported;
     bool m_list_threads_in_stop_reply;
 
     PacketResult
protected:
 
     PacketResult
     Handle_qGroupName (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_qSpeedTest (StringExtractorGDBRemote &packet);
 
     PacketResult
-    Handle_qKillSpawnedProcess (StringExtractorGDBRemote &packet);
-
-    PacketResult
     Handle_vFile_Open (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_vFile_Close (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_vFile_pRead (StringExtractorGDBRemote &packet);
 
protected:
     Handle_QEnvironment (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_QEnvironmentHexEncoded (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_QLaunchArch (StringExtractorGDBRemote &packet);
 
-    bool
-    KillSpawnedProcess (lldb::pid_t pid);
-
     static void
     CreateProcessInfoResponse (const ProcessInstanceInfo &proc_info,
                                StreamString &response);
 
     static void
     CreateProcessInfoResponse_DebugServerStyle (const ProcessInstanceInfo &proc_info,
                                                 StreamString &response);
 

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

#else
     const static uint32_t g_default_packet_timeout_sec = 0; // not specified
 #endif
 
 //----------------------------------------------------------------------
 // GDBRemoteCommunicationServerCommon constructor
 //----------------------------------------------------------------------
 GDBRemoteCommunicationServerCommon::GDBRemoteCommunicationServerCommon(const char *comm_name, const char *listener_name) :
     GDBRemoteCommunicationServer (comm_name, listener_name),
-    m_spawned_pids (),
-    m_spawned_pids_mutex (Mutex::eMutexTypeRecursive),
     m_process_launch_info (),
     m_process_launch_error (),
     m_proc_infos (),
     m_proc_infos_index (0),
     m_thread_suffix_supported (false),
     m_list_threads_in_stop_reply (false)
 {
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_A,
                                   &GDBRemoteCommunicationServerCommon::Handle_A);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_QEnvironment,
                                   &GDBRemoteCommunicationServerCommon::Handle_QEnvironment);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_QEnvironmentHexEncoded,
                                   &GDBRemoteCommunicationServerCommon::Handle_QEnvironmentHexEncoded);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qfProcessInfo,
                                   &GDBRemoteCommunicationServerCommon::Handle_qfProcessInfo);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qGroupName,
                                   &GDBRemoteCommunicationServerCommon::Handle_qGroupName);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qHostInfo,
                                   &GDBRemoteCommunicationServerCommon::Handle_qHostInfo);
-    RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qKillSpawnedProcess,
-                                  &GDBRemoteCommunicationServerCommon::Handle_qKillSpawnedProcess);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_QLaunchArch,
                                   &GDBRemoteCommunicationServerCommon::Handle_QLaunchArch);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qLaunchSuccess,
                                   &GDBRemoteCommunicationServerCommon::Handle_qLaunchSuccess);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_QListThreadsInStopReply,
                                   &GDBRemoteCommunicationServerCommon::Handle_QListThreadsInStopReply);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qEcho,
                                   &GDBRemoteCommunicationServerCommon::Handle_qEcho);
if (success && key.compare("response_size") == 0)
             }
             return SendPacketNoLock (response.GetData(), response.GetSize());
         }
     }
     return SendErrorResponse (7);
 }
 
 GDBRemoteCommunication::PacketResult
-GDBRemoteCommunicationServerCommon::Handle_qKillSpawnedProcess (StringExtractorGDBRemote &packet)
-{
-    packet.SetFilePos(::strlen ("qKillSpawnedProcess:"));
-
-    lldb::pid_t pid = packet.GetU64(LLDB_INVALID_PROCESS_ID);
-
-    // verify that we know anything about this pid.
-    // Scope for locker
-    {
-        Mutex::Locker locker (m_spawned_pids_mutex);
-        if (m_spawned_pids.find(pid) == m_spawned_pids.end())
-        {
-            // not a pid we know about
-            return SendErrorResponse (10);
-        }
-    }
-
-    // go ahead and attempt to kill the spawned process
-    if (KillSpawnedProcess (pid))
-        return SendOKResponse ();
-    else
-        return SendErrorResponse (11);
-}
-
-bool
-GDBRemoteCommunicationServerCommon::KillSpawnedProcess (lldb::pid_t pid)
-{
-    // make sure we know about this process
-    {
-        Mutex::Locker locker (m_spawned_pids_mutex);
-        if (m_spawned_pids.find(pid) == m_spawned_pids.end())
-            return false;
-    }
-
-    // first try a SIGTERM (standard kill)
-    Host::Kill (pid, SIGTERM);
-
-    // check if that worked
-    for (size_t i=0; i<10; ++i)
-    {
-        {
-            Mutex::Locker locker (m_spawned_pids_mutex);
-            if (m_spawned_pids.find(pid) == m_spawned_pids.end())
-            {
-                // it is now killed
-                return true;
-            }
-        }
-        usleep (10000);
-    }
-
-    // check one more time after the final usleep
-    {
-        Mutex::Locker locker (m_spawned_pids_mutex);
-        if (m_spawned_pids.find(pid) == m_spawned_pids.end())
-            return true;
-    }
-
-    // the launched process still lives.  Now try killing it again,
-    // this time with an unblockable signal.
-    Host::Kill (pid, SIGKILL);
-
-    for (size_t i=0; i<10; ++i)
-    {
-        {
-            Mutex::Locker locker (m_spawned_pids_mutex);
-            if (m_spawned_pids.find(pid) == m_spawned_pids.end())
-            {
-                // it is now killed
-                return true;
-            }
-        }
-        usleep (10000);
-    }
-
-    // check one more time after the final usleep
-    // Scope for locker
-    {
-        Mutex::Locker locker (m_spawned_pids_mutex);
-        if (m_spawned_pids.find(pid) == m_spawned_pids.end())
-            return true;
-    }
-
-    // no luck - the process still lives
-    return false;
-}
-
-GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_Open (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen("vFile:open:"));
     std::string path;
     packet.GetHexByteStringTerminatedBy(path,',');
     if (!path.empty())
     {
         if (packet.GetChar() == ',')

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h

protected:
 
     Error
     SetSTDIOFileDescriptor (int fd);
 
     FileSpec
     FindModuleFile (const std::string& module_path, const ArchSpec& arch) override;
 
 private:
-    bool
-    DebuggedProcessReaped (lldb::pid_t pid);
-
-    static bool
-    ReapDebuggedProcess (void *callback_baton,
-                         lldb::pid_t pid,
-                         bool exited,
-                         int signal,
-                         int status);
-
     void
     HandleInferiorState_Exited (NativeProcessProtocol *process);
 
     void
     HandleInferiorState_Stopped (NativeProcessProtocol *process);
 
     NativeThreadProtocolSP
     GetThreadFromSuffix (StringExtractorGDBRemote &packet);

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

GDBRemoteCommunicationServerLLGS::LaunchProcess ()
     else
     {
         if (log)
             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " skipping stdout/stderr redirection via $O: inferior will communicate over client-provided file descriptors", __FUNCTION__, m_debugged_process_sp->GetID ());
     }
 
     printf ("Launched '%s' as process %" PRIu64 "...\n", m_process_launch_info.GetArguments ().GetArgumentAtIndex (0), m_process_launch_info.GetProcessID ());
 
-    // Add to list of spawned processes.
-    lldb::pid_t pid;
-    if ((pid = m_process_launch_info.GetProcessID ()) != LLDB_INVALID_PROCESS_ID)
-    {
-        // add to spawned pids
-        Mutex::Locker locker (m_spawned_pids_mutex);
-        // On an lldb-gdbserver, we would expect there to be only one.
-        assert (m_spawned_pids.empty () && "lldb-gdbserver adding tracked process but one already existed");
-        m_spawned_pids.insert (pid);
-    }
-
     return error;
 }
 
 Error
 GDBRemoteCommunicationServerLLGS::AttachToProcess (lldb::pid_t pid)
 {
     Error error;
 
     Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS));
     if (log)
         log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64, __FUNCTION__, pid);
 
-    // Scope for mutex locker.
-    {
-        // Before we try to attach, make sure we aren't already monitoring something else.
-        Mutex::Locker locker (m_spawned_pids_mutex);
-        if (!m_spawned_pids.empty ())
-        {
-            error.SetErrorStringWithFormat ("cannot attach to a process %" PRIu64 " when another process with pid %" PRIu64 " is being debugged.", pid, *m_spawned_pids.begin());
-            return error;
-        }
+    if (m_debugged_process_sp  && m_debugged_process_sp->GetID() != LLDB_INVALID_PROCESS_ID)
+        return Error("cannot attach to a process %" PRIu64 " when another process with pid %" PRIu64 " is being debugged.", pid, m_debugged_process_sp->GetID());
 
-        // Try to attach.
-        error = NativeProcessProtocol::Attach(pid, *this, m_mainloop, m_debugged_process_sp);
-        if (!error.Success ())
-        {
-            fprintf (stderr, "%s: failed to attach to process %" PRIu64 ": %s", __FUNCTION__, pid, error.AsCString ());
-            return error;
-        }
 
-        // Setup stdout/stderr mapping from inferior.
-        auto terminal_fd = m_debugged_process_sp->GetTerminalFileDescriptor ();
-        if (terminal_fd >= 0)
-        {
-            if (log)
-                log->Printf ("ProcessGDBRemoteCommunicationServerLLGS::%s setting inferior STDIO fd to %d", __FUNCTION__, terminal_fd);
-            error = SetSTDIOFileDescriptor (terminal_fd);
-            if (error.Fail ())
-                return error;
-        }
-        else
-        {
-            if (log)
-                log->Printf ("ProcessGDBRemoteCommunicationServerLLGS::%s ignoring inferior STDIO since terminal fd reported as %d", __FUNCTION__, terminal_fd);
-        }
 
-        printf ("Attached to process %" PRIu64 "...\n", pid);
 
-        // Add to list of spawned processes.
-        assert (m_spawned_pids.empty () && "lldb-gdbserver adding tracked process but one already existed");
-        m_spawned_pids.insert (pid);
-
-        return error;
-    }
-}
 
 void
 GDBRemoteCommunicationServerLLGS::InitializeDelegate (NativeProcessProtocol *process)
 {
     assert (process && "process cannot be NULL");
     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
     if (log)
     {
GDBRemoteCommunicationServerLLGS::HandleInferiorState_Exited (NativeProcessProtocol *process)
 
     PacketResult result = SendStopReasonForState(StateType::eStateExited);
     if (result != PacketResult::Success)
     {
         if (log)
             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to send stop notification for PID %" PRIu64 ", state: eStateExited", __FUNCTION__, process->GetID ());
     }
 
-    // Remove the process from the list of spawned pids.
-    {
-        Mutex::Locker locker (m_spawned_pids_mutex);
-        if (m_spawned_pids.erase (process->GetID ()) < 1)
-        {
-            if (log)
-                log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to remove PID %" PRIu64 " from the spawned pids list", __FUNCTION__, process->GetID ());
-
-        }
-    }
-
     // Close the pipe to the inferior terminal i/o if we launched it
     // and set one up.
     MaybeCloseInferiorTerminalConnection ();
 
     // We are ready to exit the debug monitor.
     m_exit_now = true;
 }
 
if (!thread_sp)
         return SendErrorResponse (69);
 
     StreamString response;
     response.Printf ("QC%" PRIx64, thread_sp->GetID ());
 
     return SendPacketNoLock (response.GetData(), response.GetSize());
 }
 
-bool
-GDBRemoteCommunicationServerLLGS::DebuggedProcessReaped (lldb::pid_t pid)
-{
-    // reap a process that we were debugging (but not debugserver)
-    Mutex::Locker locker (m_spawned_pids_mutex);
-    return m_spawned_pids.erase(pid) > 0;
-}
-
-bool
-GDBRemoteCommunicationServerLLGS::ReapDebuggedProcess (void *callback_baton,
-                                        lldb::pid_t pid,
-                                        bool exited,
-                                        int signal,    // Zero for no signal
-                                        int status)    // Exit value of process if signal is zero
-{
-    GDBRemoteCommunicationServerLLGS *server = (GDBRemoteCommunicationServerLLGS *)callback_baton;
-    server->DebuggedProcessReaped (pid);
-    return true;
-}
-
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_k (StringExtractorGDBRemote &packet)
 {
     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
     StopSTDIOForwarding();
 
     if (! m_debugged_process_sp)

 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_D (StringExtractorGDBRemote &packet)
 {
     Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS));
 
     StopSTDIOForwarding();
 
-    // Scope for mutex locker.
-    Mutex::Locker locker (m_spawned_pids_mutex);
-
     // Fail if we don't have a current process.
     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
     {
         if (log)
             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__);
         return SendErrorResponse (0x15);
     }
 
-    if (m_spawned_pids.find(m_debugged_process_sp->GetID ()) == m_spawned_pids.end())
-    {
-        if (log)
-            log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to find PID %" PRIu64 " in spawned pids list",
-                         __FUNCTION__, m_debugged_process_sp->GetID ());
-        return SendErrorResponse (0x1);
-    }
-
     lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
 
     // Consume the ';' after D.
     packet.SetFilePos (1);
     if (packet.GetBytesLeft ())
     {
         if (packet.GetChar () != ';')
             return SendIllFormedResponse (packet, "D missing expected ';'");
GDBRemoteCommunicationServerLLGS::Handle_D (StringExtractorGDBRemote &packet)
     if (error.Fail ())
     {
         if (log)
             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to detach from pid %" PRIu64 ": %s\n",
                          __FUNCTION__, m_debugged_process_sp->GetID (), error.AsCString ());
         return SendErrorResponse (0x01);
     }
 
-    m_spawned_pids.erase (m_debugged_process_sp->GetID ());
     return SendOKResponse ();
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo (StringExtractorGDBRemote &packet)
 {
     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
 

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h

 //===-- GDBRemoteCommunicationServerPlatform.h ------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_GDBRemoteCommunicationServerPlatform_h_
 #define liblldb_GDBRemoteCommunicationServerPlatform_h_
 
 #include "GDBRemoteCommunicationServerCommon.h"
 
+#include <set>
+
 namespace lldb_private {
 namespace process_gdb_remote {
 
 class GDBRemoteCommunicationServerPlatform :
     public GDBRemoteCommunicationServerCommon
 {
 public:
     typedef std::map<uint16_t, lldb::pid_t> PortMap;
public:
 
     bool
     FreePortForProcess (lldb::pid_t pid);
 
     void
     SetPortOffset (uint16_t port_offset);
 
 protected:
+    Mutex m_spawned_pids_mutex;
+    std::set<lldb::pid_t> m_spawned_pids;
     lldb::PlatformSP m_platform_sp;
 
     PortMap m_port_map;
     uint16_t m_port_offset;
 
     PacketResult
     Handle_qLaunchGDBServer (StringExtractorGDBRemote &packet);
 
     PacketResult
+    Handle_qKillSpawnedProcess (StringExtractorGDBRemote &packet);
+
+    PacketResult
     Handle_qProcessInfo (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_qGetWorkingDir (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_QSetWorkingDir (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_qC (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_jSignalsInfo(StringExtractorGDBRemote &packet);
 
 private:
     bool
+    KillSpawnedProcess (lldb::pid_t pid);
+
+    bool
     DebugserverProcessReaped (lldb::pid_t pid);
 
     static bool
     ReapDebugserverProcess (void *callback_baton,
                             lldb::pid_t pid,
                             bool exited,
                             int signal,
                             int status);

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;
 
 //----------------------------------------------------------------------
 // GDBRemoteCommunicationServerPlatform constructor
 //----------------------------------------------------------------------
 GDBRemoteCommunicationServerPlatform::GDBRemoteCommunicationServerPlatform() :
     GDBRemoteCommunicationServerCommon ("gdb-remote.server", "gdb-remote.server.rx_packet"),
+    m_spawned_pids_mutex (Mutex::eMutexTypeRecursive),
     m_platform_sp (Platform::GetHostPlatform ()),
     m_port_map (),
     m_port_offset(0)
 {
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qC,
                                   &GDBRemoteCommunicationServerPlatform::Handle_qC);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qGetWorkingDir,
                                   &GDBRemoteCommunicationServerPlatform::Handle_qGetWorkingDir);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qLaunchGDBServer,
                                   &GDBRemoteCommunicationServerPlatform::Handle_qLaunchGDBServer);
+    RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qKillSpawnedProcess,
+                                  &GDBRemoteCommunicationServerPlatform::Handle_qKillSpawnedProcess);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qProcessInfo,
                                   &GDBRemoteCommunicationServerPlatform::Handle_qProcessInfo);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_QSetWorkingDir,
                                   &GDBRemoteCommunicationServerPlatform::Handle_QSetWorkingDir);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_jSignalsInfo,
                                   &GDBRemoteCommunicationServerPlatform::Handle_jSignalsInfo);
 
     RegisterPacketHandler(StringExtractorGDBRemote::eServerPacketType_interrupt,
else
         if (log)
             log->Printf ("GDBRemoteCommunicationServerPlatform::%s() debugserver launch failed: %s", __FUNCTION__, error.AsCString ());
     }
     return SendErrorResponse (9);
 #endif
 }
 
 GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServerPlatform::Handle_qKillSpawnedProcess (StringExtractorGDBRemote &packet)
+{
+    packet.SetFilePos(::strlen ("qKillSpawnedProcess:"));
+
+    lldb::pid_t pid = packet.GetU64(LLDB_INVALID_PROCESS_ID);
+
+    // verify that we know anything about this pid.
+    // Scope for locker
+    {
+        Mutex::Locker locker (m_spawned_pids_mutex);
+        if (m_spawned_pids.find(pid) == m_spawned_pids.end())
+        {
+            // not a pid we know about
+            return SendErrorResponse (10);
+        }
+    }
+
+    // go ahead and attempt to kill the spawned process
+    if (KillSpawnedProcess (pid))
+        return SendOKResponse ();
+    else
+        return SendErrorResponse (11);
+}
+
+bool
+GDBRemoteCommunicationServerPlatform::KillSpawnedProcess (lldb::pid_t pid)
+{
+    // make sure we know about this process
+    {
+        Mutex::Locker locker (m_spawned_pids_mutex);
+        if (m_spawned_pids.find(pid) == m_spawned_pids.end())
+            return false;
+    }
+
+    // first try a SIGTERM (standard kill)
+    Host::Kill (pid, SIGTERM);
+
+    // check if that worked
+    for (size_t i=0; i<10; ++i)
+    {
+        {
+            Mutex::Locker locker (m_spawned_pids_mutex);
+            if (m_spawned_pids.find(pid) == m_spawned_pids.end())
+            {
+                // it is now killed
+                return true;
+            }
+        }
+        usleep (10000);
+    }
+
+    // check one more time after the final usleep
+    {
+        Mutex::Locker locker (m_spawned_pids_mutex);
+        if (m_spawned_pids.find(pid) == m_spawned_pids.end())
+            return true;
+    }
+
+    // the launched process still lives.  Now try killing it again,
+    // this time with an unblockable signal.
+    Host::Kill (pid, SIGKILL);
+
+    for (size_t i=0; i<10; ++i)
+    {
+        {
+            Mutex::Locker locker (m_spawned_pids_mutex);
+            if (m_spawned_pids.find(pid) == m_spawned_pids.end())
+            {
+                // it is now killed
+                return true;
+            }
+        }
+        usleep (10000);
+    }
+
+    // check one more time after the final usleep
+    // Scope for locker
+    {
+        Mutex::Locker locker (m_spawned_pids_mutex);
+        if (m_spawned_pids.find(pid) == m_spawned_pids.end())
+            return true;
+    }
+
+    // no luck - the process still lives
+    return false;
+}
+
+GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerPlatform::Handle_qProcessInfo (StringExtractorGDBRemote &packet)
 {
     lldb::pid_t pid = m_process_launch_info.GetProcessID ();
     m_process_launch_info.Clear ();
 
     if (pid == LLDB_INVALID_PROCESS_ID)
         return SendErrorResponse (1);