Extend SBPlatform with capability to launch/terminate a process remotely. Integrate this change into test framework in order to spawn processes on a remote target.

[ovyalov]

Summary

1. Added Platform::Kill call which raises SIGTERM signal in its base implementation and sends qKillSpawnedProcess request in case of PlatformRemoteGDBServer.
2. Extended SBPLatform with Launch and Kill methods.
3. A few fixes within GDBRemoteCommunicationClient and GDBRemoteCommunicationServer in order to properly deliver qProcessInfo response (disabling default PID caching).
4. Small utility class hierarchy in lldbtest - _BaseProcess, _LocalProcess and _RemoteProcess to manage process launch/termination depending on test mode.

[vharron]

test/functionalities/process_attach/TestProcessAttach.py

59

Hi Greg,

In lldb, when I create a target, it is created in the context of the selected platform. Currently, when I launch a process, it is launched in the context of the selected target.

I would prefer 'process attach' to be done in the context of the currently selected platform. That way, whether you don't need to remember attaching to local/remote processes.

[ovyalov]

test/functionalities/process_attach/TestProcessAttach.py

59

It makes sense since "process launch " allows to launch remote process in case of connected platform.
I hacked a quick change for CommandObjectProcess to make it use platform:

if (platform_sp->CanDebugProcess())
 {
     process_sp = platform_sp->Attach(m_options.attach_info, m_interpreter.GetDebugger(), nullptr, error); // PlatformRemoteGDBServer needs to call HijackProcessEvents on process.
 }
 else
 {
     const char *plugin_name = m_options.attach_info.GetProcessPluginName();
     process_sp = target->CreateProcess (m_interpreter.GetDebugger().GetListener(), plugin_name, NULL);
     if (process_sp)
     {
         process_sp->HijackProcessEvents(listener_sp.get());
         error = process_sp->Attach (m_options.attach_info);
     }
 }

It's working remotely but crashing locally for me.
So, I can revert TestProcessAttach.py in this CL and then follow-up with CL for CommandObjectProcess.

[ovyalov]

I reverted TestProcessAttach changes and merged with http://reviews.llvm.org/D7358 - no regressions noticed for local test runs on Ubuntu and OSX, remote Linux->Linux execution of TestProcessAttach works fine.
Please take another look.

Thank you!

[ovyalov]

Friendly ping.

[clayborg]

See comments in the code and let me know what you think.

include/lldb/API/SBPlatform.h

106–134

Can't we just use SBLaunchInfo instead of this?

Also one thing to note: if you add anything to the lldb::SB API, you can only have one member variable: a pointer, an std::unique_ptr<> or a std::shared_pointer<>. Why? Because we are vending a C++ interface and you can't change the size of the class. When people link against the lldb.so, they need a consistent API and layout of classes in case they make classes that inherit from or use a lldb::SB class so the layout can never change. So to work around this we have rules:

1 - lldb::SB classes have one ivar (ptr, unique_ptr, or shared_ptr) which abstracts you from your implementation and makes sure the size of the lldb::SB object never changes
2 - no virtual functions so that all function lookups are based off of a pure name lookup by the dynamic linkers (no vtable that can change on you)
3 - No inheritance, or only inheritance based on other lldb::SB classes that obey the same rules

205–212

Can't this just be a SBLaunchInfo?

source/API/SBPlatform.cpp

262–304

Hopefully this class doesn't need to exist, and we can just use SBLaunchInfo. If not, then all ivars (m_command, m_working_dir, m_arch and m_pid will need to go into a Impl class and the SBPlatformLaunchCommand class will need to have a std::unique_ptr<> to the imp class.

[ovyalov]

Please see my comments.

include/lldb/API/SBPlatform.h

106–134

Thanks for suggestions and context.

I think it makes sense to use SBLaunchInfo instead of SBPlatformLaunchCommand since SBLaunchInfo is a wrapper around ProcessLaunchInfo which Platform::LaunchProcess takes as a parameter. A few follow-up questions:

• Is it ok to remove friendship between SBLaunchInfo and SBTarget and make SBLaunchInfo::ref public since it will be used by SBPlatform and SBTarget? Or we can make SBPlatform its friend as well..
• I'm going to add SBLaunchInfo::GetProcessID that will delegate to ProcessLaunchInfo::SBLaunchInfo - so, I can grab pid of launched process.
• Does it sound okay to extract SBLaunchInfo into separate SBLaunchInfo.h(cpp) files?

[ki.stfu]

include/lldb/API/SBPlatform.h

106–134

Is it ok to remove friendship between SBLaunchInfo and SBTarget and make SBLaunchInfo::ref public since it will be used by SBPlatform and SBTarget? Or we can make SBPlatform its friend as well..

I think we can make its friend. The ref() must be a private.

Does it sound okay to extract SBLaunchInfo into separate SBLaunchInfo.h(cpp) files?

Yes.

[clayborg]

Is it ok to remove friendship between SBLaunchInfo and SBTarget and make SBLaunchInfo::ref public since it will be used by SBPlatform and SBTarget? Or we can make SBPlatform its friend as well..

Make SBPlatform a friend as well

I'm going to add SBLaunchInfo::GetProcessID that will delegate to ProcessLaunchInfo::SBLaunchInfo - so, I can grab pid of launched process.

sounds good

Does it sound okay to extract SBLaunchInfo into separate SBLaunchInfo.h(cpp) files?

Sure thing. Feel free to do the same for SBAttachInfo if you have time. I can deal with the fallout in the Xcode project if you don't have a Mac once you get those in.

[ovyalov]

Extracted SBLaunchInfo (with added GetProcessID method) into a separate file and updated all build dependencies - checked on Ubuntu and OSX, didn't spot any regressions.
The CL's already become pretty big - let me extract SBAttachInfo with another CL.

Please take another look.
Thank you.

[clayborg]

Changes inlined into code as comments.

include/lldb/API/SBPlatform.h

14–15

We shouldn't need these in the header file. Only a reference to SBLaunchInfo is used below. Put them in the .cpp file.

source/API/SBPlatform.cpp

219

Remove this line so there are no diffs generated here.

[ovyalov]

Fixed according to suggestions.

[clayborg]

lgtm

[ovyalov]

Committed as http://reviews.llvm.org/rL228230

include/lldb/API/SBPlatform.h

14–15

Fixed.

source/API/SBPlatform.cpp

219

Done.

include/lldb/API/SBPlatform.h

 //===-- SBPlatform.h --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SBPlatform_h_
 #define LLDB_SBPlatform_h_
 
 #include "lldb/API/SBDefines.h"
 
+#include <functional>
+#include <string>
+
 struct PlatformConnectOptions;
 struct PlatformShellCommand;
 
 namespace lldb {
 
     class SBPlatformConnectOptions
     {
     public:
public:
         GetOutput ();
 
     protected:
         friend class SBPlatform;
 
         PlatformShellCommand *m_opaque_ptr;
     };
 
+    class SBPlatformLaunchCommand
+    {
+    public:
+        SBPlatformLaunchCommand (const char* command,
+                                 const char* working_dir,
+                                 const char* arch);
+
+        const char*
+        GetCommand () const;
+
+        const char*
+        GetWorkingDir () const;
+
+        const char*
+        GetArch () const;
+
+        const lldb::pid_t&
+        GetPID () const;
+
+        void
+        SetPID (const lldb::pid_t& pid);
+
+    private:
+        const std::string m_command;
+        const std::string m_working_dir;
+        const std::string m_arch;
+        lldb::pid_t m_pid;
+    };
+
     class SBPlatform
     {
     public:
         
         SBPlatform ();
         
         SBPlatform (const char *platform_name);
         
public:
         Get (SBFileSpec &src, SBFileSpec &dst);
 
         SBError
         Install (SBFileSpec& src, SBFileSpec& dst);
 
         SBError
         Run (SBPlatformShellCommand &shell_command);
 
         SBError
+        Launch (SBPlatformLaunchCommand &launch_command);
+
+        SBError
+        Kill (const lldb::pid_t pid);
+
+        SBError
         MakeDirectory (const char *path, uint32_t file_permissions = eFilePermissionsDirectoryDefault);
 
         uint32_t
         GetFilePermissions (const char *path);
         
         SBError
         SetFilePermissions (const char *path, uint32_t file_permissions);
 
     protected:
         
         friend class SBDebugger;
         friend class SBTarget;
 
         lldb::PlatformSP
         GetSP () const;
         
         void
         SetSP (const lldb::PlatformSP& platform_sp);
 
+        SBError
+        ExecuteConnected (const std::function<lldb_private::Error(const lldb::PlatformSP&)>& func);
+
         lldb::PlatformSP m_opaque_sp;
     };
 
 } // namespace lldb
 
 #endif // LLDB_SBPlatform_h_

include/lldb/Target/Platform.h

//        FindPlugin (Process *process, const ConstString &plugin_name);
         //------------------------------------------------------------------
         /// Launch a new process on a platform, not necessarily for 
         /// debugging, it could be just for running the process.
         //------------------------------------------------------------------
         virtual Error
         LaunchProcess (ProcessLaunchInfo &launch_info);
 
         //------------------------------------------------------------------
+        /// Kill process on a platform.
+        //------------------------------------------------------------------
+        virtual Error
+        KillProcess (const lldb::pid_t pid);
+
+        //------------------------------------------------------------------
         /// Lets a platform answer if it is compatible with a given
         /// architecture and the target triple contained within.
         //------------------------------------------------------------------
         virtual bool
         IsCompatibleArchitecture (const ArchSpec &arch,
                                   bool exact_arch_match,
                                   ArchSpec *compatible_arch_ptr);
 

scripts/Python/interface/SBPlatform.i

public:
     
     int
     GetStatus ();
     
     const char *
     GetOutput ();
 };
 
+class SBPlatformLaunchCommand
+{
+public:
+    SBPlatformLaunchCommand (const char* command,
+                             const char* working_dir,
+                             const char* arch);
+
+    const char*
+    GetCommand () const;
+
+    const char*
+    GetWorkingDir () const;
+
+    const char*
+    GetArch () const;
+
+    const lldb::pid_t&
+    GetPID () const;
+
+    void
+    SetPID (const lldb::pid_t& pid);
+};
+
 %feature("docstring",
 "A class that represents the a platform that can represent the current host or a remote host debug platform.
 
 The SBPlatform class represents the current host, or a remote host.
 It can be connected to a remote platform in order to provide ways
 to remotely launch and attach to processes, upload/download files,
 create directories, run remote shell commands, find locally cached
 versions of files from the remote system, and much more.
public:
     
     lldb::SBError
     Install (lldb::SBFileSpec &src, lldb::SBFileSpec &dst);
     
     lldb::SBError
     Run (lldb::SBPlatformShellCommand &shell_command);
 
     lldb::SBError
+    Launch (lldb::SBPlatformLaunchCommand &launch_command);
+
+    lldb::SBError
+    Kill (const lldb::pid_t pid);
+
+    lldb::SBError
     MakeDirectory (const char *path, uint32_t file_permissions = lldb::eFilePermissionsDirectoryDefault);
     
     uint32_t
     GetFilePermissions (const char *path);
     
     lldb::SBError
     SetFilePermissions (const char *path, uint32_t file_permissions);
 
 };
 
 } // namespace lldb

source/API/SBPlatform.cpp

 //===-- SBPlatform.cpp ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBPlatform.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Host/File.h"
 #include "lldb/Interpreter/Args.h"
+#include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Platform.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // PlatformConnectOptions

 const char *
 SBPlatformShellCommand::GetWorkingDirectory ()
 {
     if (m_opaque_ptr->m_working_dir.empty())
         return NULL;
     return m_opaque_ptr->m_working_dir.c_str();
 }
 
+
 void
 SBPlatformShellCommand::SetWorkingDirectory (const char *path)
 {
     if (path && path[0])
         m_opaque_ptr->m_working_dir = path;
     else
         m_opaque_ptr->m_working_dir.clear();
 }

 SBPlatformShellCommand::GetOutput ()
 {
     if (m_opaque_ptr->m_output.empty())
         return NULL;
     return m_opaque_ptr->m_output.c_str();
 }
 
 //----------------------------------------------------------------------
+// SBPlatformLaunchCommand
+//----------------------------------------------------------------------
+
+SBPlatformLaunchCommand::SBPlatformLaunchCommand (const char* command,
+                                                  const char* working_dir,
+                                                  const char* arch) :
+    m_command (command ? command : ""),
+    m_working_dir (working_dir ? working_dir: ""),
+    m_arch (arch ? arch: ""),
+    m_pid(LLDB_INVALID_PROCESS_ID)
+{
+}
+
+const char*
+SBPlatformLaunchCommand::GetCommand () const
+{
+    return m_command.c_str ();
+}
+
+const char*
+SBPlatformLaunchCommand::GetWorkingDir () const
+{
+    return m_working_dir.c_str ();
+}
+
+const char*
+SBPlatformLaunchCommand::GetArch () const
+{
+    return m_arch.c_str ();
+}
+
+const lldb::pid_t&
+SBPlatformLaunchCommand::GetPID () const
+{
+    return m_pid;
+}
+
+void
+SBPlatformLaunchCommand::SetPID (const lldb::pid_t& pid)
+{
+    m_pid = pid;
+}
+
+//----------------------------------------------------------------------
 // SBPlatform
 //----------------------------------------------------------------------
 SBPlatform::SBPlatform () :
     m_opaque_sp ()
 {
     
 }
 
SBPlatform::Get (SBFileSpec &src,
     }
     return sb_error;
 }
 
 SBError
 SBPlatform::Put (SBFileSpec &src,
                  SBFileSpec &dst)
 {
-    SBError sb_error;
-    
-    PlatformSP platform_sp(GetSP());
-    if (platform_sp)
+  return ExecuteConnected(
+      [&](const lldb::PlatformSP& platform_sp)
       {
           if (src.Exists())
           {
               uint32_t permissions = src.ref().GetPermissions();
               if (permissions == 0)
               {
                   if (src.ref().GetFileType() == FileSpec::eFileTypeDirectory)
                       permissions = eFilePermissionsDirectoryDefault;
                   else
                       permissions = eFilePermissionsFileDefault;
               }
 
-            sb_error.ref() = platform_sp->PutFile(src.ref(),
-                                                  dst.ref(),
-                                                  permissions);
-        }
-        else
-        {
-            sb_error.ref().SetErrorStringWithFormat("'src' argument doesn't exist: '%s'", src.ref().GetPath().c_str());
+              return platform_sp->PutFile(src.ref(), dst.ref(), permissions);
           }
-    }
-    else
-    {
-        sb_error.SetErrorString("invalid platform");
-    }
-    return sb_error;
+
+          Error error;
+          error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'", src.ref().GetPath().c_str());
+          return error;
+      });
 }
 
 SBError
 SBPlatform::Install (SBFileSpec &src,
                      SBFileSpec &dst)
 {
-    SBError sb_error;
-    PlatformSP platform_sp(GetSP());
-    if (platform_sp)
+  return ExecuteConnected(
+      [&](const lldb::PlatformSP& platform_sp)
       {
           if (src.Exists())
-        {
-            sb_error.ref() = platform_sp->Install(src.ref(), dst.ref());
-        }
-        else
-        {
-            sb_error.ref().SetErrorStringWithFormat("'src' argument doesn't exist: '%s'", src.ref().GetPath().c_str());
-        }
-    }
-    else
-    {
-        sb_error.SetErrorString("invalid platform");
-    }
-    return sb_error;
+              return platform_sp->Install(src.ref(), dst.ref());
+
+          Error error;
+          error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'", src.ref().GetPath().c_str());
+          return error;
+      });
 }
 
 
 SBError
 SBPlatform::Run (SBPlatformShellCommand &shell_command)
 {
-    SBError sb_error;
-    PlatformSP platform_sp(GetSP());
-    if (platform_sp)
-    {
-        if (platform_sp->IsConnected())
+    return ExecuteConnected(
+        [&](const lldb::PlatformSP& platform_sp)
         {
             const char *command = shell_command.GetCommand();
-            if (command)
-            {
-                const char *working_dir = shell_command.GetWorkingDirectory();
-                if (working_dir == NULL)
-                {
-                    working_dir = platform_sp->GetWorkingDirectory().GetCString();
-                    if (working_dir)
-                        shell_command.SetWorkingDirectory(working_dir);
-                }
-                sb_error.ref() = platform_sp->RunShellCommand(command,
-                                                              working_dir,
-                                                              &shell_command.m_opaque_ptr->m_status,
-                                                              &shell_command.m_opaque_ptr->m_signo,
-                                                              &shell_command.m_opaque_ptr->m_output,
-                                                              shell_command.m_opaque_ptr->m_timeout_sec);
-            }
-            else
-            {
-                sb_error.SetErrorString("invalid shell command (empty)");
-            }
-        }
-        else
-        {
+            if (!command)
+                return Error("invalid shell command (empty)");
+
+            return platform_sp->RunShellCommand(command,
+        });
+
+SBError
+SBPlatform::Launch (SBPlatformLaunchCommand &launch_command)
+{
+    return ExecuteConnected(
+        [&](const lldb::PlatformSP& platform_sp)
+            auto command = launch_command.GetCommand();
+            if (!command)
+                return Error("invalid launch command (empty)");
+
+            ProcessLaunchInfo launch_info;
+            launch_info.SetArguments(Args(command), true);
+
+            auto working_dir = launch_command.GetWorkingDir();
+            if (working_dir == nullptr)
+                working_dir = platform_sp->GetWorkingDirectory().GetCString();
+            launch_info.SetWorkingDirectory(working_dir);
+            auto arch = launch_command.GetArch();
+            if (arch)
+                launch_info.SetArchitecture(ArchSpec(arch));
+            else
+                launch_info.SetArchitecture(platform_sp->GetRemoteSystemArchitecture());
+
+            auto error = platform_sp->LaunchProcess(launch_info);
+            if (error.Success())
+                launch_command.SetPID(launch_info.GetProcessID());
+
+            return error;
+        });
+
+SBError
+SBPlatform::Kill (const lldb::pid_t pid)
+{
+    return ExecuteConnected(
+        [&](const lldb::PlatformSP& platform_sp)
+        {
+            return platform_sp->KillProcess(pid);
+        });
+
+SBError
+SBPlatform::ExecuteConnected (const std::function<Error(const lldb::PlatformSP&)>& func)
+{
+    SBError sb_error;
+    const auto platform_sp(GetSP());
+    if (platform_sp)
+        if (platform_sp->IsConnected())
+            sb_error.ref() = func(platform_sp);
+        else
             sb_error.SetErrorString("not connected");
-        }
-    }
     else
-    {
         sb_error.SetErrorString("invalid platform");
-    }
-    return sb_error;
+
 }
 
 SBError
 SBPlatform::MakeDirectory (const char *path, uint32_t file_permissions)
 {
     SBError sb_error;
     PlatformSP platform_sp(GetSP());
     if (platform_sp)

source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h

GetProcessInfo (lldb::pid_t pid,
                     lldb_private::ProcessInstanceInfo &proc_info);
     
     virtual uint32_t
     FindProcesses (const lldb_private::ProcessInstanceInfoMatch &match_info,
                    lldb_private::ProcessInstanceInfoList &process_infos);
 
     virtual lldb_private::Error
     LaunchProcess (lldb_private::ProcessLaunchInfo &launch_info);
-    
+    virtual lldb_private::Error
+    KillProcess (const lldb::pid_t pid);
+
     virtual lldb::ProcessSP
     DebugProcess (lldb_private::ProcessLaunchInfo &launch_info,
                   lldb_private::Debugger &debugger,
                   lldb_private::Target *target,       // Can be NULL, if NULL create a new target, else use existing one
                   lldb_private::Error &error);
 
     virtual lldb::ProcessSP
     Attach (lldb_private::ProcessAttachInfo &attach_info,

source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

 }
 
 
 Error
 PlatformRemoteGDBServer::LaunchProcess (ProcessLaunchInfo &launch_info)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
     Error error;
-    lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
 
     if (log)
         log->Printf ("PlatformRemoteGDBServer::%s() called", __FUNCTION__);
 
     m_gdb_client.SetSTDIN ("/dev/null");
     m_gdb_client.SetSTDOUT ("/dev/null");
     m_gdb_client.SetSTDERR ("/dev/null");
     m_gdb_client.SetDisableASLR (launch_info.GetFlags().Test (eLaunchFlagDisableASLR));
PlatformRemoteGDBServer::LaunchProcess (ProcessLaunchInfo &launch_info)
     const uint32_t old_packet_timeout = m_gdb_client.SetPacketTimeout (5);
     int arg_packet_err = m_gdb_client.SendArgumentsPacket (launch_info);
     m_gdb_client.SetPacketTimeout (old_packet_timeout);
     if (arg_packet_err == 0)
     {
         std::string error_str;
         if (m_gdb_client.GetLaunchSuccess (error_str))
         {
-            pid = m_gdb_client.GetCurrentProcessID ();
+            const auto pid = m_gdb_client.GetCurrentProcessID (false);
             if (pid != LLDB_INVALID_PROCESS_ID)
             {
                 launch_info.SetProcessID (pid);
                 if (log)
                     log->Printf ("PlatformRemoteGDBServer::%s() pid %" PRIu64 " launched successfully", __FUNCTION__, pid);
             }
             else
             {
                 if (log)
                     log->Printf ("PlatformRemoteGDBServer::%s() launch succeeded but we didn't get a valid process id back!", __FUNCTION__);
-                // FIXME isn't this an error condition? Do we need to set an error here?  Check with Greg.
+                error.SetErrorString ("failed to get PID");
             }
         }
         else
         {
             error.SetErrorString (error_str.c_str());
             if (log)
                 log->Printf ("PlatformRemoteGDBServer::%s() launch failed: %s", __FUNCTION__, error.AsCString ());
         }
     }
     else
     {
         error.SetErrorStringWithFormat("'A' packet returned an error: %i", arg_packet_err);
     }
     return error;
 }
 
+Error
+PlatformRemoteGDBServer::KillProcess (const lldb::pid_t pid)
+{
+    if (!m_gdb_client.KillSpawnedProcess(pid))
+        return Error("failed to kill remote spawned process");
+    return Error();
+}
+
 lldb::ProcessSP
 PlatformRemoteGDBServer::DebugProcess (lldb_private::ProcessLaunchInfo &launch_info,
                                        lldb_private::Debugger &debugger,
                                        lldb_private::Target *target,       // Can be NULL, if NULL create a new target, else use existing one
                                        lldb_private::Error &error)
 {
     lldb::ProcessSP process_sp;
     if (IsRemote())

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

public:
     SendAsyncSignal (int signo);
 
     bool
     SendInterrupt (lldb_private::Mutex::Locker &locker, 
                    uint32_t seconds_to_wait_for_stop, 
                    bool &timed_out);
 
     lldb::pid_t
-    GetCurrentProcessID ();
+    GetCurrentProcessID (bool allow_lazy = true);
 
     bool
     GetLaunchSuccess (std::string &error_str);
 
     uint16_t
     LaunchGDBserverAndGetPort (lldb::pid_t &pid, const char *remote_accept_hostname);
     
     bool

 protected:
 
     PacketResult
     SendPacketAndWaitForResponseNoLock (const char *payload,
                                         size_t payload_length,
                                         StringExtractorGDBRemote &response);
 
     bool
-    GetCurrentProcessInfo ();
+    GetCurrentProcessInfo (bool allow_lazy_pid = true);
 
     bool
     GetGDBServerVersion();
 
     //------------------------------------------------------------------
     // Classes that inherit from GDBRemoteCommunicationClient can see and modify these
     //------------------------------------------------------------------
     lldb_private::LazyBool m_supports_not_sending_acks;

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

)
     {
         if (log)
             log->Printf ("SendInterrupt () - not running");
     }
     return true;
 }
 
 lldb::pid_t
-GDBRemoteCommunicationClient::GetCurrentProcessID ()
+GDBRemoteCommunicationClient::GetCurrentProcessID (bool allow_lazy)
 {
-    if (m_curr_pid_is_valid == eLazyBoolYes)
+    if (allow_lazy && m_curr_pid_is_valid == eLazyBoolYes)
         return m_curr_pid;
     
     // First try to retrieve the pid via the qProcessInfo request.
-    GetCurrentProcessInfo ();
+    GetCurrentProcessInfo (allow_lazy);
     if (m_curr_pid_is_valid == eLazyBoolYes)
     {
         // We really got it.
         return m_curr_pid;
     }
     else
     {
         // If we don't get a response for qProcessInfo, check if $qC gives us a result.
if (m_supports_qProcessInfoPID)
             m_supports_qProcessInfoPID = false;
             return false;
         }
     }
     return false;
 }
 
 bool
-GDBRemoteCommunicationClient::GetCurrentProcessInfo ()
+GDBRemoteCommunicationClient::GetCurrentProcessInfo (bool allow_lazy)
 {
     Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet (GDBR_LOG_PROCESS | GDBR_LOG_PACKETS));
 
+    if (allow_lazy)
+    {
         if (m_qProcessInfo_is_valid == eLazyBoolYes)
             return true;
         if (m_qProcessInfo_is_valid == eLazyBoolNo)
             return false;
+    }
 
     GetHostInfo ();
 
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse ("qProcessInfo", response, false) == PacketResult::Success)
     {
         if (response.IsNormalResponse())
         {

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

if (!error.Success ())
         fprintf (stderr, "%s: failed to launch executable %s", __FUNCTION__, m_process_launch_info.GetArguments ().GetArgumentAtIndex (0));
         return error;
     }
 
     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.  On an lldb-gdbserver, we
     // would expect there to be only one.
-    lldb::pid_t pid;
-    if ( (pid = m_process_launch_info.GetProcessID()) != LLDB_INVALID_PROCESS_ID )
+    const auto pid = m_process_launch_info.GetProcessID();
+    if (pid != LLDB_INVALID_PROCESS_ID)
     {
         // add to spawned pids
-        {
-            Mutex::Locker locker (m_spawned_pids_mutex);
-            m_spawned_pids.insert(pid);
-        }
-    }
 
     return error;
 }
 
 lldb_private::Error
 GDBRemoteCommunicationServer::AttachToProcess (lldb::pid_t pid)
 {
     Error error;
#endif
     }
 
 }
 
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::Handle_qProcessInfo (StringExtractorGDBRemote &packet)
 {
-    // Only the gdb server handles this.
-    if (!IsGdbServer ())
-        return SendUnimplementedResponse (packet.GetStringRef ().c_str ());
-    
+    lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
+    if (IsGdbServer ())
+    {
         // Fail if we don't have a current process.
         if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
             return SendErrorResponse (68);
-    
-    ProcessInstanceInfo proc_info;
-    if (Host::GetProcessInfo (m_debugged_process_sp->GetID (), proc_info))
+        pid = m_debugged_process_sp->GetID ();
+    }
+    else if (m_is_platform)
     {
-        StreamString response;
-        CreateProcessInfoResponse_DebugServerStyle(proc_info, response);
-        return SendPacketNoLock (response.GetData (), response.GetSize ());
+        pid = m_process_launch_info.GetProcessID ();
     }
-    
+    else
+        return SendUnimplementedResponse (packet.GetStringRef ().c_str ());
+
+    if (pid == LLDB_INVALID_PROCESS_ID)
+        return SendErrorResponse (1);
+    ProcessInstanceInfo proc_info;
+    if (!Host::GetProcessInfo (pid, proc_info))
         return SendErrorResponse (1);
+
+    StreamString response;
+    CreateProcessInfoResponse_DebugServerStyle(proc_info, response);
+    return SendPacketNoLock (response.GetData (), response.GetSize ());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::Handle_qProcessInfoPID (StringExtractorGDBRemote &packet)
 {
     // Packet format: "qProcessInfoPID:%i" where %i is the pid
     packet.SetFilePos(::strlen ("qProcessInfoPID:"));
     lldb::pid_t pid = packet.GetU32 (LLDB_INVALID_PROCESS_ID);

source/Target/Platform.cpp

if (IsHost())
 
         error = Host::LaunchProcess (launch_info);
     }
     else
         error.SetErrorString ("base lldb_private::Platform class can't launch remote processes");
     return error;
 }
 
+Error
+Platform::KillProcess (const lldb::pid_t pid)
+{
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
+    if (log)
+        log->Printf ("Platform::%s, pid %" PRIu64, __FUNCTION__, pid);
+
+    if (!IsHost ())
+        return Error ("base lldb_private::Platform class can't launch remote processes");
+
+    Host::Kill (pid, SIGTERM);
+    return Error();
+}
+
 lldb::ProcessSP
 Platform::DebugProcess (ProcessLaunchInfo &launch_info, 
                         Debugger &debugger,
                         Target *target,       // Can be NULL, if NULL create a new target, else use existing one
                         Error &error)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
     if (log)

test/functionalities/process_attach/TestProcessAttach.py

def process_attach_by_id(self):
         """Test attach by process id"""
 
         exe = os.path.join(os.getcwd(), exe_name)
 
         # Spawn a new process
         popen = self.spawnSubprocess(exe)
         self.addTearDownHook(self.cleanupSubprocesses)
 
+        if lldb.remote_platform:
+            self.runCmd("platform process attach -p " + str(popen.pid))
+        else:
             self.runCmd("process attach -p " + str(popen.pid))
 
         target = self.dbg.GetSelectedTarget()
 
         process = target.GetProcess()
         self.assertTrue(process, PROCESS_IS_VALID)
 
-
     def process_attach_by_name(self):
         """Test attach by process name"""
 
         exe = os.path.join(os.getcwd(), exe_name)
 
         # Spawn a new process
         popen = self.spawnSubprocess(exe)
         self.addTearDownHook(self.cleanupSubprocesses)
 
+        if lldb.remote_platform:
+            self.runCmd("platform process attach -n " + exe_name)
+        else:
             self.runCmd("process attach -n " + exe_name)
 
         target = self.dbg.GetSelectedTarget()
 
         process = target.GetProcess()
         self.assertTrue(process, PROCESS_IS_VALID)
 
 
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()

test/lldbtest.py

 ........................................................................
 ----------------------------------------------------------------------
 Ran 72 tests in 135.468s
 
 OK
 $ 
 """
 
+import abc
 import os, sys, traceback
 import os.path
 import re
 import signal
 from subprocess import *
 import StringIO
 import time
 import types
 import unittest2
 import lldb
+from _pyio import __metaclass__
 
 # See also dotest.parseOptionsAndInitTestdirs(), where the environment variables
 # LLDB_COMMAND_TRACE and LLDB_DO_CLEANUP are set from '-t' and '-r dir' options.
 
 # By default, traceAlways is False.
 if "LLDB_COMMAND_TRACE" in os.environ and os.environ["LLDB_COMMAND_TRACE"]=="YES":
     traceAlways = True
 else:
def __exit__(self, type, value, tb):
         recordings to our session object.  And close the StringIO object, too.
         """
         if self.trace:
             print >> sys.stderr, self.getvalue()
         if self.session:
             print >> self.session, self.getvalue()
         self.close()
 
+class _BaseProcess(object):
+    __metaclass__ = abc.ABCMeta
+
+    @abc.abstractproperty
+    def pid(self):
+        """Returns process PID if has been launched already."""
+
+    @abc.abstractmethod
+    def launch(self, executable, args):
+        """Launches new process with given executable and args."""
+
+    @abc.abstractmethod
+    def terminate(self):
+        """Terminates previously launched process.."""
+
+class _LocalProcess(_BaseProcess):
+
+    def __init__(self, trace_on):
+        self._proc = None
+        self._trace_on = trace_on
+
+    @property
+    def pid(self):
+        return self._proc.pid
+
+    def launch(self, executable, args):
+        self._proc = Popen([executable] + args,
+                           stdout = open(os.devnull) if not self._trace_on else None,
+                           stdin = PIPE)
+
+    def terminate(self):
+        if self._proc.poll() == None:
+            self._proc.terminate()
+
+class _RemoteProcess(_BaseProcess):
+
+    def __init__(self):
+        self._pid = None
+
+    @property
+    def pid(self):
+        return self._pid
+
+    def launch(self, executable, args):
+        remote_work_dir = lldb.remote_platform.GetWorkingDirectory()
+        src_path = executable
+        dst_path = os.path.join(remote_work_dir, os.path.basename(executable))
+
+        err = lldb.remote_platform.Install(lldb.SBFileSpec(src_path, True),
+                                           lldb.SBFileSpec(dst_path, False))
+        if err.Fail():
+            raise Exception("remote_platform.Install('%s', '%s') failed: %s" % (src_path, dst_path, err))
+
+        cmd = lldb.SBPlatformLaunchCommand(' '.join([dst_path] + args),
+                                           remote_work_dir,
+                                           None)
+        err = lldb.remote_platform.Launch(cmd)
+        if err.Fail():
+            raise Exception("remote_platform.Launch('%s', '%s') failed: %s" % (dst_path, args, err))
+        self._pid = cmd.GetPID()
+
+    def terminate(self):
+        err = lldb.remote_platform.Kill(self._pid)
+        if err.Fail():
+            raise Exception("remote_platform.Kill(%d) failed: %s" % (self._pid, err))
+
 # From 2.7's subprocess.check_output() convenience function.
 # Return a tuple (stdoutdata, stderrdata).
 def system(commands, **kwargs):
     r"""Run an os command with arguments and return its output as a byte string.
 
     If the exit code was non-zero it raises a CalledProcessError.  The
     CalledProcessError object will have the return code in the returncode
     attribute and output in the output attribute.
def setAsync(self, value):
         """ Sets async mode to True/False and ensures it is reset after the testcase completes."""
         old_async = self.dbg.GetAsync()
         self.dbg.SetAsync(value)
         self.addTearDownHook(lambda: self.dbg.SetAsync(old_async))
 
     def cleanupSubprocesses(self):
         # Ensure any subprocesses are cleaned up
         for p in self.subprocesses:
-            if p.poll() == None:
-                p.terminate()
             del p
         del self.subprocesses[:]
         # Ensure any forked processes are cleaned up
         for pid in self.forkedProcessPids:
             if os.path.exists("/proc/" + str(pid)):
                 os.kill(pid, signal.SIGTERM)
 
     def spawnSubprocess(self, executable, args=[]):
         """ Creates a subprocess.Popen object with the specified executable and arguments,
             saves it in self.subprocesses, and returns the object.
             NOTE: if using this function, ensure you also call:
 
               self.addTearDownHook(self.cleanupSubprocesses)
 
             otherwise the test suite will leak processes.
         """
-
-        # Don't display the stdout if not in TraceOn() mode.
-        proc = Popen([executable] + args,
-                     stdout = open(os.devnull) if not self.TraceOn() else None,
-                     stdin = PIPE)
+        proc = _RemoteProcess() if lldb.remote_platform else _LocalProcess(self.TraceOn())
+        proc.launch(executable, args)
         self.subprocesses.append(proc)
         return proc
 
     def forkSubprocess(self, executable, args=[]):
         """ Fork a subprocess with its own group ID.
             NOTE: if using this function, ensure you also call:
 
               self.addTearDownHook(self.cleanupSubprocesses)