Modify "platform connect" to connect to processes as well

[tberghammer]

Summary

Modify "platform connect" to connect to processes as well

The standard remote debugging workflow with gdb is to start the
application on the remote host under gdbserver (e.g.: gdbserver :5039
a.out) and then connect to it with gdb.

The same workflow is supported by debugserver/lldb-gdbserver with a very
similar syntax but to access all features of lldb we need to be
connected also to an lldb-platform instance running on the target.

Before this change this had to be done manually with starting a separate
lldb-platform on the target machine and then connecting to it with lldb
before connecting to the process.

This change modifies the behavior of "platform connect" with
automatically connecting to the process instance if it was started by
the remote platform. With this command replacing gdbserver in a gdb
based worflow is usually as simple as replacing the command to execute
gdbserver with executing lldb-platform.

Example for the new workflow:

• On the target: lldb-server platform --listen localhost:5432 -- a.out arg1 arg2
• On the host: (lldb) platform select remote-android (lldb) platform connect connect://localhost:5432
• As a result we will be connected to the remote platform and also connected to a process of a.out on the remote target what is stopped at the entry point (the executable file and all of its dependency will be downloaded by the platform to the module cache)

[labath]

Seems like a reasonable thing to do. However, we should first add a test for the new functionality.

source/Commands/CommandObjectPlatform.cpp

1977

Please update this as well.
With this many suboptions, we can go for something like
platform process <command> [<command-options>], as other commands do.

[tberghammer]

Add test

[tberghammer]

source/Commands/CommandObjectPlatform.cpp

1976–1986

Done

[labath]

Thank you for writing the test. I have just a couple of more comments and them I'm done... :)

Please wait for @clayborg to sign off on this as well.

packages/Python/lldbsuite/test/tools/lldb-server/platform-process-connect/TestPlatformProcessConnect.py

14

I'm quite opposed to "inline skips", I'd like them to be more declarative. Let's add a "remote" parameter to the skipIf decorator and use that. Suggested semantics:

• None: don't care
• True: skip if the target is remote
• False: skip if the target is *not* remote

27

Please spell out the arguments in full. It makes it much more obvious what is going to happen.

30

What will happen when the next test runs? Will we be able to reconnect to the old platform instance? Please check whether this works when run in --no-multiprocess mode with other tests...
If it does not work, we might be able to create a brand new SBDebugger instance and use that to connect...

[tberghammer]

Improve the test based on the comments

packages/Python/lldbsuite/test/tools/lldb-server/platform-process-connect/TestPlatformProcessConnect.py

14

Done

27

Done

30

I changed it to create a new debugger because the previous implementation only worked if the test wasn't followed by a new one

[clayborg]

I am not sure that I like this new "platform process connect" command as it isn't really clear what this command does. "platform connect" connects to the remote platform, "process connect" connects directly to a remote GDB server that is already running. Can we just modify "platform connect" to do what "platform process connect" currently does? The code for "platform connect" would just need to detect that the platform has a process that it needs to attach do and do it. I believe this would keep the functionality that you want and keep our commands intact and a bit cleaner.

[tberghammer]

I decided to go with the "platform process connect" command as it connects to both to a platform and to a process instances at the same time but I agree it is not very clear.

We can make this the default functionality for "platform connect" but then we have to add a new packet to the gdb protocol where lldb can ask the platform if it have to connect to a process instance or not. I am not sure if using "platform connect" will be clearer enough to give us a reason to add a new packet because in that case it will have 2 slightly different functionality based on the way lldb-platform was started on the remote target.

If you prefer adding the functionality to "platform connect" then I am happy with that solution also but I am not convinced it is any better then this approach.

[labath]

FWIW, I like Greg's idea. The operation seems quite intuitive to me: "platform connect" connects to the platform, and if that happens to have a process ready, then it sets that up as well..

[clayborg]

I am fine with adding a new platform GDB remote packet that queries for a list of processes that we need to connect to after we attach. It might be nice for clients to be able to vend N number of processes that should be attached to when the platform is connected to. This could have people that implement the GDB remote platform for JTAG style devices that connected up to a chip with multiple cores. When they do "platform connect" they would be immediately connected to all cores.

So I suggest adding some sort of packet that gives back a list of process IDs that we should attach to, and then attach to each of them.

[labath]

Just a tiny remark from my side..

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

184

The TMPDIR and "sleep" comments seem to be obsolete...

[clayborg]

So my main issue with this is the new virtual "Platform::GetPendingGdbServerList(...)" function. Can we remove this function and just put the functionality into Platform::ContectRemote()?

include/lldb/Target/Platform.h

1029–1030

Why is something GDB server specific in Platform.h? There has to be a better way.

source/Commands/CommandObjectPlatform.cpp

413–429

This should just be done inside ConnectRemote so we don't have to expose GetPendingGdbServerList() which is GDB remote specific. If we can't do this functionality inside ConnectRemote we need to add a more suitable abstract API that is protocol agnostic.

source/Plugins/Platform/POSIX/PlatformPOSIX.h

191–192

Remove and move functionality into ConnectRemote()

[tberghammer]

I can't move the functionality into Platform::ConnectRemote because to connect to a process we need a debugger instance while Platform::ConnectRemote is called in scenarios where we don't have access to it (from SBPlatform::ConnectRemote). To clean up the API I added a new method to the Platform class called ConnectToWaitingProcesses what is connecting to all process waiting for a new debugger connection. In case of remote debugging it can be based on the gdb protocol (what I implemented with this CL) but if somebody want to support an embedded system with 1 process for each core then ConnectToWaitingProcesses can create a process for each core instead of connecting over the gdb protocol and everything should just work.

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

184

Done

[clayborg]

Looks good, just check me inline comment and make changes if you think you need to.

source/Commands/CommandObjectPlatform.cpp

414–419

So should the default Platform::ConnectToWaitingProcesses() return an error? Seems like this calls should be documented to say "only return an error if you actually tried to connect to a waiting process and that failed, and if there are no processes, return an error that has been cleared". We don't want "platform connect" to fail due to not being able to connect to a waiting process do we?

[tberghammer]

source/Commands/CommandObjectPlatform.cpp

414–419

I agree that we don't want "platform connect" to fail if no process is waiting (if a process is waiting but we failed to connect then I think it should but it isn't the case with the default platform).

Currently ConnectToWaitingProcesses tries to connect to all processes what are waiting what is 0 processes for the default platform and return an error if any of them failed, but with 0 processes waiting it can't happen.

docs/lldb-gdb-remote.txt

 server to expedite memory that the client is likely to use (e.g., areas around the
 stack pointer, which are needed for computing backtraces) and it reduces the packet
 count.
 
 On MacOSX with debugserver, we expedite the frame pointer backchain for a thread
 (up to 256 entries) by reading 2 pointers worth of bytes at the frame pointer (for
 the previous FP and PC), and follow the backchain. Most backtraces on MacOSX and
 iOS now don't require us to read any memory!
+
+//----------------------------------------------------------------------
+// "qQueryGDBServer"
+//
+// BRIEF
+//  Ask the platform for the list of gdbservers we have to connect
+//
+// PRIORITY TO IMPLEMENT
+//  Low. The packet is required to support connecting to gdbserver started
+//  by the platform instance automatically.
+//----------------------------------------------------------------------
+
+If the remote platform automatically started one or more gdbserver instance (without
+lldb asking it) then it have to return the list of port number or socket name for
+each of them what can be used by lldb to connect to those instances.
+
+The data in this packet is a JSON array of JSON objects with the following keys:
+"port":        <the port number to connect>        (optional)
+"socket_name": <the name of the socket to connect> (optional)
+
+Example packet:
+[
+    { "port": 1234 },
+    { "port": 5432 },
+    { "socket_name": "foo" }
+]

include/lldb/Target/Platform.h

//        FindPlugin (Process *process, const ConstString &plugin_name);
         /// process that will debug the debuggee.
         //------------------------------------------------------------------
         virtual lldb::ProcessSP
         DebugProcess (ProcessLaunchInfo &launch_info,
                       Debugger &debugger,
                       Target *target,       // Can be nullptr, if nullptr create a new target, else use existing one
                       Error &error);
 
+        virtual lldb::ProcessSP
+        ConnectProcess (const char* connect_url,
+                        const char* plugin_name,
+                        lldb_private::Debugger &debugger,
+                        lldb_private::Target *target,
+                        lldb_private::Error &error);
+
         //------------------------------------------------------------------
         /// Attach to an existing process using a process ID.
         ///
         /// Each platform subclass needs to implement this function and 
         /// attempt to attach to the process with the process ID of \a pid.
         /// The platform subclass should return an appropriate ProcessSP 
         /// subclass that is attached to the process, or an empty shared 
         /// pointer with an appropriate error.
//                Error &error) = 0;
         virtual uint32_t
         LoadImage (lldb_private::Process* process,
                    const lldb_private::FileSpec& image_spec,
                    lldb_private::Error& error);
 
         virtual Error
         UnloadImage (lldb_private::Process* process, uint32_t image_token);
 
+        //------------------------------------------------------------------
+        /// Connect to all processes waiting for a debugger to attach
+        ///
+        /// If the platform have a list of processes waiting for a debugger
+        /// to connect to them then connect to all of these pending processes.
+        ///
+        /// @param[in] debugger
+        ///     The debugger used for the connect.
+        ///
+        /// @param[out] error
+        ///     If an error occurred during the connect then this object will
+        ///     contain the error message.
+        ///
+        /// @return
+        ///     The number of processes we are succesfully connected to.
+        //------------------------------------------------------------------
+        virtual size_t
+        ConnectToWaitingProcesses(lldb_private::Debugger& debugger, lldb_private::Error& error);
+
     protected:
         bool m_is_host;
         // Set to true when we are able to actually set the OS version while
         // being connected. For remote platforms, we might set the version ahead
         // of time before we actually connect and this version might change when
         // we actually connect to a remote platform. For the host platform this
         // will be set to the once we call HostInfo::GetOSVersion().
         bool m_os_version_set_while_connected;

packages/Python/lldbsuite/test/lldbtest.py

 # provide a function to skip on defined oslist, compiler version, and archs
 # if none is specified for any argument, that argument won't be checked and thus means for all
 # for example,
 # @skipIf, skip for all platform/compiler/arch,
 # @skipIf(compiler='gcc'), skip for gcc on all platform/architecture
 # @skipIf(bugnumber, ["linux"], "gcc", ['>=', '4.9'], ['i386']), skip for gcc>=4.9 on linux with i386
 
 # TODO: refactor current code, to make skipIfxxx functions to call this function
-def skipIf(bugnumber=None, oslist=None, compiler=None, compiler_version=None, archs=None, debug_info=None, swig_version=None, py_version=None):
+def skipIf(bugnumber=None, oslist=None, compiler=None, compiler_version=None, archs=None, debug_info=None, swig_version=None, py_version=None, remote=None):
     def fn(self):
         oslist_passes = oslist is None or self.getPlatform() in oslist
         compiler_passes = compiler is None or (compiler in self.getCompiler() and self.expectedCompilerVersion(compiler_version))
         arch_passes = self.expectedArch(archs)
         debug_info_passes = debug_info is None or self.debug_info in debug_info
         swig_version_passes = (swig_version is None) or (not hasattr(lldb, 'swig_version')) or (check_expected_version(swig_version[0], swig_version[1], lldb.swig_version))
         py_version_passes = (py_version is None) or check_expected_version(py_version[0], py_version[1], sys.version_info)
+        remote_passes = (remote is None) or (remote == (lldb.remote_platform is not None))
 
         return (oslist_passes and
                 compiler_passes and
                 arch_passes and
                 debug_info_passes and
                 swig_version_passes and
-                py_version_passes)
+                py_version_passes and
+                remote_passes)
 
     local_vars = locals()
     args = [x for x in inspect.getargspec(skipIf).args]
     arg_vals = [eval(x, globals(), local_vars) for x in args]
     args = [x for x in zip(args, arg_vals) if x[1] is not None]
     reasons = ['%s=%s' % (x, str(y)) for (x,y) in args]
     return skipTestIfFn(fn, bugnumber, skipReason='skipping because ' + ' && '.join(reasons))
 

packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

def get_stub_port_from_named_socket(self, read_timeout_seconds=5):
 
         # Trim null byte, convert to int.
         stub_port_raw = stub_port_raw[:-1]
         stub_port = int(stub_port_raw)
         self.assertTrue(stub_port > 0)
 
         return stub_port
 
-    def init_llgs_test(self, use_named_pipe=True):
-        if lldb.remote_platform:
-            def run_shell_cmd(cmd):
-                platform = self.dbg.GetSelectedPlatform()
-                shell_cmd = lldb.SBPlatformShellCommand(cmd)
-                err = platform.Run(shell_cmd)
-                if err.Fail() or shell_cmd.GetStatus():
-                    m = "remote_platform.RunShellCommand('%s') failed:\n" % cmd
-                    m += ">>> return code: %d\n" % shell_cmd.GetStatus()
-                    if err.Fail():
-                        m += ">>> %s\n" % str(err).strip()
-                    m += ">>> %s\n" % (shell_cmd.GetOutput() or
-                                       "Command generated no output.")
-                    raise Exception(m)
-                return shell_cmd.GetOutput().strip()
+    def run_shell_cmd(self, cmd):
+
+    def init_llgs_test(self, use_named_pipe=True):
+        if lldb.remote_platform:
             # Remote platforms don't support named pipe based port negotiation
             use_named_pipe = False
 
             # Grab the ppid from /proc/[shell pid]/stat
-            shell_stat = run_shell_cmd("cat /proc/$$/stat")
+            shell_stat = self.run_shell_cmd("cat /proc/$$/stat")
             # [pid] ([executable]) [state] [*ppid*]
             pid = re.match(r"^\d+ \(.+\) . (\d+)", shell_stat).group(1)
-            ls_output = run_shell_cmd("ls -l /proc/%s/exe" % pid)
+            ls_output = self.run_shell_cmd("ls -l /proc/%s/exe" % pid)
             exe = ls_output.split()[-1]
 
             # If the binary has been deleted, the link name has " (deleted)" appended.
             # Remove if it's there.
             self.debug_monitor_exe = re.sub(r' \(deleted\)$', '', exe)
         else:
             self.debug_monitor_exe = get_lldb_server_exe()
             if not self.debug_monitor_exe:

packages/Python/lldbsuite/test/tools/lldb-server/platform-process-connect/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/tools/lldb-server/platform-process-connect/TestPlatformProcessConnect.py

+from __future__ import print_function
+
+import gdbremote_testcase
+from lldbsuite.test.lldbtest import *
+import lldbsuite.test.lldbutil as lldbutil
+
+class TestPlatformProcessConnect(gdbremote_testcase.GdbRemoteTestCaseBase):
+    mydir = TestBase.compute_mydir(__file__)
+
+    @llgs_test
+    @no_debug_info_test
+    @skipIf(remote=False)
+    def test_platform_process_connect(self):
+        self.build()
+        self.init_llgs_test(False)
+
+        working_dir = lldb.remote_platform.GetWorkingDirectory()
+        err = lldb.remote_platform.Put(lldb.SBFileSpec(os.path.join(os.getcwd(), "a.out")),
+                                       lldb.SBFileSpec(os.path.join(working_dir, "a.out")))
+        if err.Fail():
+            raise RuntimeError("Unable copy '%s' to '%s'.\n>>> %s" % (f, wd, err.GetCString()))
+
+        port_file = "%s/port" % working_dir
+        commandline_args = ["platform", "--listen", "*:0", "--socket-file", port_file, "--", "%s/a.out" % working_dir, "foo"]
+        self.spawnSubprocess(self.debug_monitor_exe, commandline_args, install_remote=False)
+        self.addTearDownHook(self.cleanupSubprocesses)
+        new_port = self.run_shell_cmd("while [ ! -f %s ]; do sleep 0.25; done && cat %s" % (port_file, port_file))
+
+        new_debugger = lldb.SBDebugger.Create()
+        new_debugger.SetAsync(False)
+        def del_debugger():
+            del new_debugger
+        self.addTearDownHook(del_debugger)
+
+        new_platform = lldb.SBPlatform(lldb.remote_platform.GetName())
+        new_debugger.SetSelectedPlatform(new_platform)
+        new_interpreter = new_debugger.GetCommandInterpreter()
+
+        m = re.search("(.*):[0-9]+", lldb.platform_url)
+        command = "platform connect %s:%s" % (m.group(1), new_port)
+        result = lldb.SBCommandReturnObject()
+        new_interpreter.HandleCommand(command, result)
+        self.assertTrue(result.Succeeded(), "platform process connect failed: %s" % result.GetOutput())
+
+        target = new_debugger.GetSelectedTarget()
+        process = target.GetProcess()
+        thread = process.GetThreadAtIndex(0)
+
+        breakpoint = target.BreakpointCreateByName("main")
+        process.Continue()
+
+        frame = thread.GetFrameAtIndex(0)
+        self.assertEqual(frame.GetFunction().GetName(), "main")
+        self.assertEqual(frame.FindVariable("argc").GetValueAsSigned(), 2)
+        process.Continue()

packages/Python/lldbsuite/test/tools/lldb-server/platform-process-connect/main.cpp

+#include <cstdio>
+
+int main (int argc, char **argv)
+{
+    printf("argc: %d\n", argc);
+    return argv[0][0];
+}

source/Commands/CommandObjectPlatform.cpp

DoExecute (Args& args, CommandReturnObject &result) override
         
         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
         if (platform_sp)
         {
             Error error (platform_sp->ConnectRemote (args));
             if (error.Success())
             {
                 platform_sp->GetStatus (ostrm);
-                result.SetStatus (eReturnStatusSuccessFinishResult);            
+                result.SetStatus (eReturnStatusSuccessFinishResult);
+
+                platform_sp->ConnectToWaitingProcesses(m_interpreter.GetDebugger(), error);
+                if (error.Fail())
+                {
+                    result.AppendError (error.AsCString());
+                    result.SetStatus (eReturnStatusFailed);
+                }
             }
             else
             {
                 result.AppendErrorWithFormat ("%s\n", error.AsCString());
-                result.SetStatus (eReturnStatusFailed);            
+                result.SetStatus (eReturnStatusFailed);
             }
         }
         else
         {
             result.AppendError ("no platform is currently selected\n");
             result.SetStatus (eReturnStatusFailed);            
         }
         return result.Succeeded();
     }
     
     Options *
     GetOptions () override
     {

 {
 public:
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
      CommandObjectPlatformProcess (CommandInterpreter &interpreter) :
         CommandObjectMultiword (interpreter,
                                 "platform process",
                                 "A set of commands to query, launch and attach to platform processes",
                                 "platform process [attach|launch|list] ...")
     {
         LoadSubCommand ("attach", CommandObjectSP (new CommandObjectPlatformProcessAttach (interpreter)));
         LoadSubCommand ("launch", CommandObjectSP (new CommandObjectPlatformProcessLaunch (interpreter)));
         LoadSubCommand ("info"  , CommandObjectSP (new CommandObjectPlatformProcessInfo (interpreter)));
         LoadSubCommand ("list"  , CommandObjectSP (new CommandObjectPlatformProcessList (interpreter)));
 
     }
     
     ~CommandObjectPlatformProcess () override
     {
     }
     
 private:
     //------------------------------------------------------------------
     // For CommandObjectPlatform only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (CommandObjectPlatformProcess);

source/Commands/CommandObjectProcess.cpp

public:
     {
         return &m_options;
     }
     
 protected:
     bool
     DoExecute (Args& command, CommandReturnObject &result) override
     {
-        
-        TargetSP target_sp (m_interpreter.GetDebugger().GetSelectedTarget());
-        Error error;        
-        Process *process = m_exe_ctx.GetProcessPtr();
-        if (process)
-        {
-            if (process->IsAlive())
-            {
-                result.AppendErrorWithFormat ("Process %" PRIu64 " is currently being debugged, kill the process before connecting.\n",
-                                              process->GetID());
-                result.SetStatus (eReturnStatusFailed);
-                return false;
-            }
-        }
-        
-        if (!target_sp)
-        {
-            // If there isn't a current target create one.
-            
-            error = m_interpreter.GetDebugger().GetTargetList().CreateTarget (m_interpreter.GetDebugger(), 
-                                                                              NULL,
-                                                                              NULL, 
-                                                                              false,
-                                                                              NULL, // No platform options
-                                                                              target_sp);
-            if (!target_sp || error.Fail())
-            {
-                result.AppendError(error.AsCString("Error creating target"));
-                result.SetStatus (eReturnStatusFailed);
-                return false;
-            }
-            m_interpreter.GetDebugger().GetTargetList().SetSelectedTarget(target_sp.get());
-        }
-        
-        if (command.GetArgumentCount() == 1)
-        {
-            const char *plugin_name = NULL;
-            if (!m_options.plugin_name.empty())
-                plugin_name = m_options.plugin_name.c_str();
+        if (command.GetArgumentCount() != 1)
+            result.AppendErrorWithFormat ("'%s' takes exactly one argument:\nUsage: %s\n",
+                                          m_cmd_name.c_str(),
+                                          m_cmd_syntax.c_str());
+        Process *process = m_exe_ctx.GetProcessPtr();
+        if (process && process->IsAlive())
+            result.AppendErrorWithFormat ("Process %" PRIu64 " is currently being debugged, kill the process before connecting.\n",
+                                          process->GetID());
+        const char *plugin_name = nullptr;
 
-            const char *remote_url = command.GetArgumentAtIndex(0);
-            process = target_sp->CreateProcess (m_interpreter.GetDebugger().GetListener(), plugin_name, NULL).get();
-            
-            if (process)
-            {
-                error = process->ConnectRemote (process->GetTarget().GetDebugger().GetOutputFile().get(), remote_url);
-
-                if (error.Fail())
-                {
-                    result.AppendError(error.AsCString("Remote connect failed"));
-                    result.SetStatus (eReturnStatusFailed);
-                    target_sp->DeleteCurrentProcess();
-                    return false;
-                }
-            }
-            else
-            {
-                result.AppendErrorWithFormat ("Unable to find process plug-in for remote URL '%s'.\nPlease specify a process plug-in name with the --plugin option, or specify an object file using the \"file\" command.\n", 
-                                              remote_url);
-                result.SetStatus (eReturnStatusFailed);
-            }
-        }
-        else
-        {
-            result.AppendErrorWithFormat ("'%s' takes exactly one argument:\nUsage: %s\n", 
-                                          m_cmd_name.c_str(),
-                                          m_cmd_syntax.c_str());
-            result.SetStatus (eReturnStatusFailed);
-        }
-        return result.Succeeded();
+        Error error;
+        Debugger& debugger = m_interpreter.GetDebugger();
+        PlatformSP platform_sp = m_interpreter.GetPlatform(true);
+        ProcessSP process_sp = platform_sp->ConnectProcess(command.GetArgumentAtIndex(0),
+                                                           plugin_name,
+                                                           debugger,
+                                                           debugger.GetSelectedTarget().get(),
+                                                           error);
+        if (error.Fail() || process_sp == nullptr)
+            result.AppendError(error.AsCString("Error connecting to the process"));
+        return true;
     }
-    
     CommandOptions m_options;
 };
 
 OptionDefinition
 CommandObjectProcessConnect::CommandOptions::g_option_table[] =
 {
     { LLDB_OPT_SET_ALL, false, "plugin", 'p', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypePlugin, "Name of the process plugin you want to use."},
     { 0,                false, NULL,      0 , 0,                 NULL, NULL, 0, eArgTypeNone,   NULL }

source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.h

public:
     ~PlatformAndroidRemoteGDBServer() override;
 
     Error
     ConnectRemote (Args& args) override;
 
     Error
     DisconnectRemote () override;
 
+    lldb::ProcessSP
+    ConnectProcess (const char* connect_url,
+                    const char* plugin_name,
+                    lldb_private::Debugger &debugger,
+                    lldb_private::Target *target,
+                    lldb_private::Error &error) override;
+
+    size_t
+    ConnectToWaitingProcesses(lldb_private::Debugger& debugger, lldb_private::Error& error) override;
+
 protected:
     std::string m_device_id;
     std::map<lldb::pid_t, uint16_t> m_port_forwards;
     llvm::Optional<AdbClient::UnixSocketNamespace> m_socket_namespace;
 
     bool
     LaunchGDBServer (lldb::pid_t &pid, std::string &connect_url) override;
 

source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp

for (auto i = 0; i < kAttempsNum; ++i)
             url_str << "connect://localhost:" << local_port;
             connect_url = url_str.str();
             break;
         }
     }
 
     return error;
 }
+
+lldb::ProcessSP
+PlatformAndroidRemoteGDBServer::ConnectProcess(const char* connect_url,
+                                               const char* plugin_name,
+                                               lldb_private::Debugger &debugger,
+                                               lldb_private::Target *target,
+                                               lldb_private::Error &error)
+{
+    // We don't have the pid of the remote gdbserver when it isn't started by us but we still want
+    // to store the list of port forwards we set up in our port forward map. Generate a fake pid for
+    // these cases what won't collide with any other valid pid on android.
+    static lldb::pid_t s_remote_gdbserver_fake_pid = 0xffffffffffffffffULL;
+
+    int remote_port;
+    std::string scheme, host, path;
+    if (!UriParser::Parse(connect_url, scheme, host, remote_port, path))
+    {
+        error.SetErrorStringWithFormat("Invalid URL: %s", connect_url);
+        return nullptr;
+    }
+
+    std::string new_connect_url;
+    error = MakeConnectURL(s_remote_gdbserver_fake_pid--,
+                           (remote_port < 0) ? 0 : remote_port,
+                           path.c_str(),
+                           new_connect_url);
+    if (error.Fail())
+        return nullptr;
+
+    return PlatformRemoteGDBServer::ConnectProcess(new_connect_url.c_str(),
+                                                   plugin_name,
+                                                   debugger,
+                                                   target,
+                                                   error);
+}
+
+size_t
+PlatformAndroidRemoteGDBServer::ConnectToWaitingProcesses(Debugger& debugger, Error& error)
+{
+    std::vector<std::string> connection_urls;
+    GetPendingGdbServerList(connection_urls);
+
+    for (size_t i = 0; i < connection_urls.size(); ++i)
+    {
+        ConnectProcess(connection_urls[i].c_str(), nullptr, debugger, nullptr, error);
+        if (error.Fail())
+            return i; // We already connected to i process succsessfully
+    }
+    return connection_urls.size();
+}

source/Plugins/Platform/POSIX/PlatformPOSIX.h

public:
     uint32_t
     LoadImage (lldb_private::Process* process,
                const lldb_private::FileSpec& image_spec,
                lldb_private::Error& error) override;
 
     lldb_private::Error
     UnloadImage (lldb_private::Process* process, uint32_t image_token) override;
 
+    lldb::ProcessSP
+    ConnectProcess (const char* connect_url,
+                    const char* plugin_name,
+                    lldb_private::Debugger &debugger,
+                    lldb_private::Target *target,
+                    lldb_private::Error &error) override;
+                    
+    size_t
+    ConnectToWaitingProcesses(lldb_private::Debugger& debugger, lldb_private::Error& error) override;
+
 protected:
     std::unique_ptr<lldb_private::OptionGroupOptions> m_options;
     lldb::PlatformSP m_remote_platform_sp; // Allow multiple ways to connect to a remote POSIX-compliant OS
 
     lldb_private::Error
     EvaluateLibdlExpression(lldb_private::Process* process,
                             const char *expr_cstr,
                             const char *expr_prefix,

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

PlatformPOSIX::UnloadImage (lldb_private::Process* process, uint32_t image_token)
     Scalar scalar;
     if (result_valobj_sp->ResolveValue(scalar))
     {
         if (scalar.UInt(1))
             return Error("expression failed: \"%s\"", expr.GetData());
         process->ResetImageToken(image_token);
     }
     return Error();
-}
+}   
 
+lldb::ProcessSP
+PlatformPOSIX::ConnectProcess (const char* connect_url,
+                               const char* plugin_name,
+                               lldb_private::Debugger &debugger,
+                               lldb_private::Target *target,
+                               lldb_private::Error &error)
+{
+    if (m_remote_platform_sp)
+        return m_remote_platform_sp->ConnectProcess(connect_url,
+                                                    plugin_name,
+                                                    debugger,
+                                                    target,
+                                                    error);
+
+    return Platform::ConnectProcess(connect_url, plugin_name, debugger, target, error);
+}
+
 const char*
 PlatformPOSIX::GetLibdlFunctionDeclarations() const
 {
     return R"(
               extern "C" void* dlopen(const char*, int);
               extern "C" void* dlsym(void*, const char*);
               extern "C" int   dlclose(void*);
               extern "C" char* dlerror(void);
              )";
 }
+
+size_t
+PlatformPOSIX::ConnectToWaitingProcesses(Debugger& debugger, Error& error)
+{
+    if (m_remote_platform_sp)
+        return m_remote_platform_sp->ConnectToWaitingProcesses(debugger, error);
+    return Platform::ConnectToWaitingProcesses(debugger, error);
+}

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

RunShellCommand(const char *command,            // Shouldn't be NULL
                     uint32_t timeout_sec) override; // Timeout in seconds to wait for shell program to finish
 
     void
     CalculateTrapHandlerSymbolNames () override;
 
     const lldb::UnixSignalsSP &
     GetRemoteUnixSignals() override;
 
+    lldb::ProcessSP
+    ConnectProcess (const char* connect_url,
+                    const char* plugin_name,
+                    lldb_private::Debugger &debugger,
+                    lldb_private::Target *target,
+                    lldb_private::Error &error) override;
+
+    virtual size_t
+    GetPendingGdbServerList(std::vector<std::string>& connection_urls);
+
 protected:
     process_gdb_remote::GDBRemoteCommunicationClient m_gdb_client;
     std::string m_platform_description; // After we connect we can get a more complete description of what we are connected to
     std::string m_platform_scheme;
     std::string m_platform_hostname;
 
     lldb::UnixSignalsSP m_remote_signals_sp;
 

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

 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
PlatformRemoteGDBServer::MakeUrl(const char* scheme,
     StreamString result;
     result.Printf("%s://%s", scheme, hostname);
     if (port != 0)
         result.Printf(":%u", port);
     if (path)
         result.Write(path, strlen(path));
     return result.GetString();
 }
+
+lldb::ProcessSP
+PlatformRemoteGDBServer::ConnectProcess(const char* connect_url,
+                                        const char* plugin_name,
+                                        lldb_private::Debugger &debugger,
+                                        lldb_private::Target *target,
+                                        lldb_private::Error &error)
+{
+    if (!IsRemote() || !IsConnected())
+    {
+        error.SetErrorString("Not connected to remote gdb server");
+        return nullptr;
+    }
+    return Platform::ConnectProcess(connect_url, plugin_name, debugger, target, error);
+}
+
+size_t
+PlatformRemoteGDBServer::GetPendingGdbServerList(std::vector<std::string>& connection_urls)
+{
+    std::vector<std::pair<uint16_t, std::string>> remote_servers;
+    m_gdb_client.QueryGDBServer(remote_servers);
+    for (const auto& gdbserver : remote_servers)
+    {
+        const char* socket_name_cstr = gdbserver.second.empty() ? nullptr : gdbserver.second.c_str();
+        connection_urls.emplace_back(MakeGdbServerUrl(m_platform_scheme,
+                                                      m_platform_hostname,
+                                                      gdbserver.first,
+                                                      socket_name_cstr));
+    }
+    return connection_urls.size();
+}

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

 // Project includes
 #include "lldb/lldb-public.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Core/Listener.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Host/Predicate.h"
 #include "lldb/Host/TimeValue.h"
+#include "lldb/Interpreter/Args.h"
 
 #include "Utility/StringExtractorGDBRemote.h"
 
 namespace lldb_private {
 namespace process_gdb_remote {
 
 typedef enum
 {
public:
     //------------------------------------------------------------------
     // Start a debugserver instance on the current host using the
     // supplied connection URL.
     //------------------------------------------------------------------
     Error
     StartDebugserverProcess(const char *url,
                             Platform *platform, // If non nullptr, then check with the platform for the GDB server binary if it can't be located
                             ProcessLaunchInfo &launch_info,
-                            uint16_t *port);
+                            uint16_t *port,
+                            const Args& inferior_args = Args());
 
     void
     DumpHistory(Stream &strm);
     
 protected:
     class History
     {
     public:

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

GDBRemoteCommunication::ListenThread (lldb::thread_arg_t arg)
     }
     return NULL;
 }
 
 Error
 GDBRemoteCommunication::StartDebugserverProcess (const char *url,
                                                  Platform *platform,
                                                  ProcessLaunchInfo &launch_info,
-                                                 uint16_t *port)
+                                                 uint16_t *port,
+                                                 const Args& inferior_args)
 {
     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
     if (log)
         log->Printf ("GDBRemoteCommunication::%s(url=%s, port=%" PRIu16, __FUNCTION__, url ? url : "<empty>", port ? *port : uint16_t(0));
 
     Error error;
     // If we locate debugserver, keep that located version around
     static FileSpec g_debugserver_file_spec;
#endif
             if (has_env_var)
             {
                 debugserver_args.AppendArgument (extra_arg);
                 if (log)
                     log->Printf ("GDBRemoteCommunication::%s adding env var %s contents to stub command line (%s)", __FUNCTION__, env_var_name, extra_arg);
             }
         } while (has_env_var);
 
+        if (inferior_args.GetArgumentCount() > 0)
+        {
+            debugserver_args.AppendArgument ("--");
+            debugserver_args.AppendArguments (inferior_args);
+        }
+
+        // Copy the current environment to the gdbserver/debugserver instance
+        StringList env;
+        if (Host::GetEnvironment(env))
+        {
+            for (size_t i = 0; i < env.GetSize(); ++i)
+                launch_info.GetEnvironmentEntries().AppendArgument(env[i].c_str());
+        }
+
         // Close STDIN, STDOUT and STDERR.
         launch_info.AppendCloseFileAction (STDIN_FILENO);
         launch_info.AppendCloseFileAction (STDOUT_FILENO);
         launch_info.AppendCloseFileAction (STDERR_FILENO);
 
         // Redirect STDIN, STDOUT and STDERR to "/dev/null".
         launch_info.AppendSuppressFileAction (STDIN_FILENO, true, false);
         launch_info.AppendSuppressFileAction (STDOUT_FILENO, false, true);

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

public:
     bool
     GetLaunchSuccess (std::string &error_str);
 
     bool
     LaunchGDBServer (const char *remote_accept_hostname,
                      lldb::pid_t &pid,
                      uint16_t &port,
                      std::string &socket_name);
-    
+    size_t
+    QueryGDBServer (std::vector<std::pair<uint16_t, std::string>>& connection_urls);
+
     bool
     KillSpawnedProcess (lldb::pid_t pid);
 
     //------------------------------------------------------------------
     /// Sends a GDB remote protocol 'A' packet that delivers program
     /// arguments to the remote server.
     ///
     /// @param[in] argv

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

if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
                 socket_name = value;
             }
         }
         return true;
     }
     return false;
 }
 
+size_t
+GDBRemoteCommunicationClient::QueryGDBServer (std::vector<std::pair<uint16_t, std::string>>& connection_urls)
+{
+    connection_urls.clear();
+
+    StringExtractorGDBRemote response;
+    if (SendPacketAndWaitForResponse("qQueryGDBServer", response, false) != PacketResult::Success)
+        return 0;
+
+    StructuredData::ObjectSP data = StructuredData::ParseJSON(response.GetStringRef());
+    if (!data)
+        return 0;
+
+    StructuredData::Array* array = data->GetAsArray();
+    if (!array)
+        return 0;
+
+    for (size_t i = 0, count = array->GetSize(); i < count; ++i)
+    {
+        StructuredData::Dictionary* element = nullptr;
+        if (!array->GetItemAtIndexAsDictionary(i, element))
+            continue;
+
+        uint16_t port = 0;
+        if (StructuredData::ObjectSP port_osp = element->GetValueForKey(llvm::StringRef("port")))
+            port = port_osp->GetIntegerValue(0);
+
+        std::string socket_name;
+        if (StructuredData::ObjectSP socket_name_osp = element->GetValueForKey(llvm::StringRef("socket_name")))
+            socket_name = socket_name_osp->GetStringValue();
+
+        if (port != 0 || !socket_name.empty())
+            connection_urls.emplace_back(port, socket_name);
+    }
+    return connection_urls.size();
+}
+
 bool
 GDBRemoteCommunicationClient::KillSpawnedProcess (lldb::pid_t pid)
 {
     StreamString stream;
     stream.Printf ("qKillSpawnedProcess:%" PRId64 , pid);
     const char *packet = stream.GetData();
     int packet_len = stream.GetSize();
 

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

public:
     FreePort (uint16_t port);
 
     bool
     FreePortForProcess (lldb::pid_t pid);
 
     void
     SetPortOffset (uint16_t port_offset);
 
+    void
+    SetInferiorArguments (const lldb_private::Args& args);
+
+    Error
+    LaunchGDBServer(const lldb_private::Args& args,
+                    std::string hostname,
+                    lldb::pid_t& pid,
+                    uint16_t& port,
+                    std::string& socket_name);
+
+    void
+    SetPendingGdbServer(lldb::pid_t pid, uint16_t port, const std::string& socket_name);
+
 protected:
     const Socket::SocketProtocol m_socket_protocol;
     const std::string m_socket_scheme;
     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;
+    struct { lldb::pid_t pid; uint16_t port; std::string socket_name; } m_pending_gdb_server;
 
     PacketResult
     Handle_qLaunchGDBServer (StringExtractorGDBRemote &packet);
 
     PacketResult
+    Handle_qQueryGDBServer (StringExtractorGDBRemote &packet);
+
+    PacketResult
     Handle_qKillSpawnedProcess (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_qProcessInfo (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_qGetWorkingDir (StringExtractorGDBRemote &packet);
 

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

 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/UnixSignals.h"
+#include "lldb/Utility/JSON.h"
 
 // Project includes
 #include "Utility/StringExtractorGDBRemote.h"
 #include "Utility/UriParser.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;
 
 //----------------------------------------------------------------------
 // GDBRemoteCommunicationServerPlatform constructor
 //----------------------------------------------------------------------
 GDBRemoteCommunicationServerPlatform::GDBRemoteCommunicationServerPlatform(const Socket::SocketProtocol socket_protocol,
                                                                            const char* socket_scheme) :
     GDBRemoteCommunicationServerCommon ("gdb-remote.server", "gdb-remote.server.rx_packet"),
     m_socket_protocol(socket_protocol),
     m_socket_scheme(socket_scheme),
     m_spawned_pids_mutex (Mutex::eMutexTypeRecursive),
     m_platform_sp (Platform::GetHostPlatform ()),
     m_port_map (),
-    m_port_offset(0)
+    m_port_offset(0),
+    m_pending_gdb_server{ LLDB_INVALID_PROCESS_ID, 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_qQueryGDBServer,
+                                  &GDBRemoteCommunicationServerPlatform::Handle_qQueryGDBServer);
     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);

 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 GDBRemoteCommunicationServerPlatform::~GDBRemoteCommunicationServerPlatform()
 {
 }
 
-GDBRemoteCommunication::PacketResult
-GDBRemoteCommunicationServerPlatform::Handle_qLaunchGDBServer (StringExtractorGDBRemote &packet)
-{
-#ifdef _WIN32
-    return SendErrorResponse(9);
-#else
-    // Spawn a local debugserver as a platform so we can then attach or launch
-    // a process...
-
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
-    if (log)
-        log->Printf ("GDBRemoteCommunicationServerPlatform::%s() called", __FUNCTION__);
-
-    // Sleep and wait a bit for debugserver to start to listen...
-    ConnectionFileDescriptor file_conn;
-    std::string hostname;
-    // TODO: /tmp/ should not be hardcoded. User might want to override /tmp
-    // with the TMPDIR environment variable
-    packet.SetFilePos(::strlen ("qLaunchGDBServer;"));
-    std::string name;
-    std::string value;
-    uint16_t port = UINT16_MAX;
-    while (packet.GetNameColonValue(name, value))
-    {
-        if (name.compare ("host") == 0)
-            hostname.swap(value);
-        else if (name.compare ("port") == 0)
-            port = StringConvert::ToUInt32(value.c_str(), 0, 0);
-    }
+Error
+GDBRemoteCommunicationServerPlatform::LaunchGDBServer(const lldb_private::Args& args,
+                                                      std::string hostname,
+                                                      lldb::pid_t& pid,
+                                                      uint16_t& port,
+                                                      std::string& socket_name)
     if (port == UINT16_MAX)
         port = GetNextAvailablePort();
     
     // Spawn a new thread to accept the port that gets bound after
     // binding to port 0 (zero).
 
     // ignore the hostname send from the remote end, just use the ip address
     // that we're currently communicating with as the hostname
 
     // Spawn a debugserver and try to get the port it listens to.
     ProcessLaunchInfo debugserver_launch_info;
     if (hostname.empty())
         hostname = "127.0.0.1";
+
+    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
     if (log)
         log->Printf("Launching debugserver with: %s:%u...", hostname.c_str(), port);
 
     // Do not run in a new session so that it can not linger after the
     // platform closes.
     debugserver_launch_info.SetLaunchInSeparateProcessGroup(false);
     debugserver_launch_info.SetMonitorProcessCallback(ReapDebugserverProcess, this, false);
 
     std::string platform_scheme;
     std::string platform_ip;
     int platform_port;
     std::string platform_path;
     bool ok = UriParser::Parse(GetConnection()->GetURI().c_str(), platform_scheme, platform_ip, platform_port, platform_path);
     UNUSED_IF_ASSERT_DISABLED(ok);
     assert(ok);
 
-    std::string socket_name;
     std::ostringstream url;
-
     uint16_t* port_ptr = &port;
-    url << m_socket_scheme << "://";
     if (m_socket_protocol == Socket::ProtocolTcp)
         url << platform_ip << ":" << port;
     else
     {
         socket_name = GetDomainSocketPath("gdbserver").GetPath();
         url << socket_name;
         port_ptr = nullptr;
     }
 
     Error error = StartDebugserverProcess (url.str().c_str(),
                                            nullptr,
                                            debugserver_launch_info,
-                                           port_ptr);
-
-    lldb::pid_t debugserver_pid = debugserver_launch_info.GetProcessID();
+                                           port_ptr,
+                                           args);
 
-
-    if (debugserver_pid != LLDB_INVALID_PROCESS_ID)
+    pid = debugserver_launch_info.GetProcessID();
+    if (pid != LLDB_INVALID_PROCESS_ID)
     {
         Mutex::Locker locker (m_spawned_pids_mutex);
-        m_spawned_pids.insert(debugserver_pid);
+        m_spawned_pids.insert(pid);
         if (port > 0)
-            AssociatePortWithProcess(port, debugserver_pid);
+            AssociatePortWithProcess(port, pid);
     }
     else
     {
         if (port > 0)
-            FreePort (port);
+            FreePort(port);
     }
+    return error;
+}
 
-    if (error.Success())
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServerPlatform::Handle_qLaunchGDBServer (StringExtractorGDBRemote &packet)
+{
+#ifdef _WIN32
+    return SendErrorResponse(9);
+#else
+    // Spawn a local debugserver as a platform so we can then attach or launch
+    // a process...
+
+    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServerPlatform::%s() called", __FUNCTION__);
+
+    ConnectionFileDescriptor file_conn;
+    std::string hostname;
+    packet.SetFilePos(::strlen ("qLaunchGDBServer;"));
+    std::string name;
+    std::string value;
+    uint16_t port = UINT16_MAX;
+    while (packet.GetNameColonValue(name, value))
+    {
+        if (name.compare ("host") == 0)
+            hostname.swap(value);
+        else if (name.compare ("port") == 0)
+            port = StringConvert::ToUInt32(value.c_str(), 0, 0);
+    }
+
+    lldb::pid_t debugserver_pid = LLDB_INVALID_PROCESS_ID;
+    std::string socket_name;
+    Error error = LaunchGDBServer(Args(), hostname, debugserver_pid, port, socket_name);
+    if (error.Fail())
     {
         if (log)
-            log->Printf ("GDBRemoteCommunicationServerPlatform::%s() debugserver launched successfully as pid %" PRIu64, __FUNCTION__, debugserver_pid);
+            log->Printf("GDBRemoteCommunicationServerPlatform::%s() debugserver launch failed: %s", __FUNCTION__, error.AsCString ());
+        return SendErrorResponse(9);
+    }
+
+    if (log)
 
-        StreamGDBRemote response;
-        response.Printf("pid:%" PRIu64 ";port:%u;", debugserver_pid, port + m_port_offset);
-        if (!socket_name.empty())
-        {
-            response.PutCString("socket_name:");
-            response.PutCStringAsRawHex8(socket_name.c_str());
-            response.PutChar(';');
-        }
 
-        PacketResult packet_result = SendPacketNoLock(response.GetData(), response.GetSize());
-        if (packet_result != PacketResult::Success)
-        {
-            if (debugserver_pid != LLDB_INVALID_PROCESS_ID)
-                ::kill (debugserver_pid, SIGINT);
-        }
-        return packet_result;
-    }
-    else
-    {
-        if (log)
-            log->Printf ("GDBRemoteCommunicationServerPlatform::%s() debugserver launch failed: %s", __FUNCTION__, error.AsCString ());
-    }
-    return SendErrorResponse (9);
-#endif
+#endif
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServerPlatform::Handle_qQueryGDBServer (StringExtractorGDBRemote &packet)
+    if (m_pending_gdb_server.pid == LLDB_INVALID_PROCESS_ID)
+        return SendErrorResponse(4);
+
+    JSONObject::SP server_sp = std::make_shared<JSONObject>();
+    server_sp->SetObject("port", std::make_shared<JSONNumber>(m_pending_gdb_server.port));
+    if (!m_pending_gdb_server.socket_name.empty())
+        server_sp->SetObject("socket_name",
+                             std::make_shared<JSONString>(m_pending_gdb_server.socket_name.c_str()));
+
+    JSONArray server_list;
+    server_list.AppendObject(server_sp);
+
+    StreamGDBRemote response;
+    server_list.Write(response);
+
+    StreamGDBRemote escaped_response;
+    escaped_response.PutEscapedBytes(response.GetData(), response.GetSize());
+    return SendPacketNoLock(escaped_response.GetData(), escaped_response.GetSize());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerPlatform::Handle_qKillSpawnedProcess (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen ("qKillSpawnedProcess:"));
 
     lldb::pid_t pid = packet.GetU64(LLDB_INVALID_PROCESS_ID);
GDBRemoteCommunicationServerPlatform::GetDomainSocketPath(const char* prefix)
     FileSpec socket_path_spec(GetDomainSocketDir());
     socket_path_spec.AppendPathComponent(socket_name.c_str());
 
     llvm::sys::fs::createUniqueFile(socket_path_spec.GetCString(), socket_path);
     return FileSpec(socket_path.c_str(), false);
 }
 
 void
-GDBRemoteCommunicationServerPlatform::SetPortOffset (uint16_t port_offset)
+GDBRemoteCommunicationServerPlatform::SetPortOffset(uint16_t port_offset)
 {
     m_port_offset = port_offset;
 }
+
+void
+GDBRemoteCommunicationServerPlatform::SetPendingGdbServer(lldb::pid_t pid,
+                                                          uint16_t port,
+                                                          const std::string& socket_name)
+{
+    m_pending_gdb_server.pid = pid;
+    m_pending_gdb_server.port = port;
+    m_pending_gdb_server.socket_name = socket_name;
+}

source/Target/Platform.cpp

 #include "lldb/Breakpoint/BreakpointIDList.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StructuredData.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Symbol/ObjectFile.h"
Platform::LoadImage(lldb_private::Process* process, const FileSpec& image_spec, Error& error)
     return LLDB_INVALID_IMAGE_TOKEN;
 }
 
 Error
 Platform::UnloadImage(lldb_private::Process* process, uint32_t image_token)
 {
     return Error("UnLoadImage is not supported on the current platform");
 }
+
+lldb::ProcessSP
+Platform::ConnectProcess(const char* connect_url,
+                         const char* plugin_name,
+                         lldb_private::Debugger &debugger,
+                         lldb_private::Target *target,
+                         lldb_private::Error &error)
+{
+    error.Clear();
+
+    if (!target)
+    {
+        TargetSP new_target_sp;
+        error = debugger.GetTargetList().CreateTarget(debugger,
+                                                      nullptr,
+                                                      nullptr,
+                                                      false,
+                                                      nullptr,
+                                                      new_target_sp);
+        target = new_target_sp.get();
+    }
+
+    if (!target || error.Fail())
+        return nullptr;
+
+    debugger.GetTargetList().SetSelectedTarget(target);
+
+    lldb::ProcessSP process_sp = target->CreateProcess(debugger.GetListener(),
+                                                       plugin_name,
+                                                       nullptr);
+    if (!process_sp)
+        return nullptr;
+
+    error = process_sp->ConnectRemote(debugger.GetOutputFile().get(), connect_url);
+    if (error.Fail())
+        return nullptr;
+
+    return process_sp;
+}
+
+size_t
+Platform::ConnectToWaitingProcesses(lldb_private::Debugger& debugger, lldb_private::Error& error)
+{
+    return 0;
+}

source/Utility/StringExtractorGDBRemote.h

enum ServerPacketType
         eServerPacketType_A, // Program arguments packet
         eServerPacketType_qfProcessInfo,
         eServerPacketType_qsProcessInfo,
         eServerPacketType_qC,
         eServerPacketType_qEcho,
         eServerPacketType_qGroupName,
         eServerPacketType_qHostInfo,
         eServerPacketType_qLaunchGDBServer,
+        eServerPacketType_qQueryGDBServer,
         eServerPacketType_qKillSpawnedProcess,
         eServerPacketType_qLaunchSuccess,
         eServerPacketType_qModuleInfo,
         eServerPacketType_qProcessInfoPID,
         eServerPacketType_qSpeedTest,
         eServerPacketType_qUserName,
         eServerPacketType_qGetWorkingDir,
         eServerPacketType_qFileLoadAddress,

source/Utility/StringExtractorGDBRemote.cpp

case 'q':
 
         case 'H':
             if (PACKET_MATCHES ("qHostInfo"))                   return eServerPacketType_qHostInfo;
             break;
 
         case 'K':
             if (PACKET_STARTS_WITH ("qKillSpawnedProcess"))     return eServerPacketType_qKillSpawnedProcess;
             break;
-        
         case 'L':
             if (PACKET_STARTS_WITH ("qLaunchGDBServer"))        return eServerPacketType_qLaunchGDBServer;
             if (PACKET_MATCHES ("qLaunchSuccess"))              return eServerPacketType_qLaunchSuccess;
             break;
-            
         case 'M':
             if (PACKET_STARTS_WITH ("qMemoryRegionInfo:"))      return eServerPacketType_qMemoryRegionInfo;
             if (PACKET_MATCHES ("qMemoryRegionInfo"))           return eServerPacketType_qMemoryRegionInfoSupported;
             if (PACKET_STARTS_WITH ("qModuleInfo:"))             return eServerPacketType_qModuleInfo;
             break;
 
         case 'P':
             if (PACKET_STARTS_WITH ("qProcessInfoPID:"))        return eServerPacketType_qProcessInfoPID;
             if (PACKET_STARTS_WITH ("qPlatform_shell:"))        return eServerPacketType_qPlatform_shell;
             if (PACKET_STARTS_WITH ("qPlatform_mkdir:"))        return eServerPacketType_qPlatform_mkdir;
             if (PACKET_STARTS_WITH ("qPlatform_chmod:"))        return eServerPacketType_qPlatform_chmod;
             if (PACKET_MATCHES ("qProcessInfo"))                return eServerPacketType_qProcessInfo;
             break;
-                
+        case 'Q':
+            if (PACKET_MATCHES ("qQueryGDBServer"))             return eServerPacketType_qQueryGDBServer;
+            break;
+
         case 'R':
             if (PACKET_STARTS_WITH ("qRcmd,"))                  return eServerPacketType_qRcmd;
             if (PACKET_STARTS_WITH ("qRegisterInfo"))           return eServerPacketType_qRegisterInfo;
             break;
 
         case 'S':
             if (PACKET_STARTS_WITH ("qSpeedTest:"))             return eServerPacketType_qSpeedTest;
             if (PACKET_MATCHES ("qShlibInfoAddr"))              return eServerPacketType_qShlibInfoAddr;

tools/lldb-server/lldb-platform.cpp

if (listen_host_port.empty())
         show_usage = true;
     
     if (show_usage || option_error)
     {
         display_usage(progname, subcommand);
         exit(option_error);
     }
 
+    // Skip any options we consumed with getopt_long_only.
+    argc -= optind;
+    argv += optind;
+    lldb_private::Args inferior_arguments;
+    inferior_arguments.SetArguments(argc, const_cast<const char**>(argv));
+
     const bool children_inherit_listen_socket = false;
     // the test suite makes many connections in parallel, let's not miss any.
     // The highest this should get reasonably is a function of the number
     // of target CPUs. For now, let's just use 100.
     const int backlog = 100;
 
     std::unique_ptr<Acceptor> acceptor_up(Acceptor::Create(listen_host_port, children_inherit_listen_socket, error));
     if (error.Fail())
     {
         fprintf(stderr, "failed to create acceptor: %s", error.AsCString());
         exit(socket_error);
     }
 
     error = acceptor_up->Listen(backlog);
     if (error.Fail())
     {
         printf("failed to listen: %s\n", error.AsCString());
         exit(socket_error);
     }
     if (socket_file)
     {
         error = save_socket_id_to_file(acceptor_up->GetLocalSocketId(), socket_file);
         if (error.Fail())
         {
-            fprintf(stderr, "failed to write socket id to %s: %s", socket_file.GetPath().c_str(), error.AsCString());
+            fprintf(stderr, "failed to write socket id to %s: %s\n", socket_file.GetPath().c_str(), error.AsCString());
             return 1;
         }
     }
 
     do {
         GDBRemoteCommunicationServerPlatform platform(acceptor_up->GetSocketProtocol(),
                                                       acceptor_up->GetSocketScheme());
-        
         if (port_offset > 0)
             platform.SetPortOffset(port_offset);
 
         if (!gdbserver_portmap.empty())
         {
             platform.SetPortMap(std::move(gdbserver_portmap));
         }
 
do {
             // If not running as a server, this process will not accept
             // connections while a connection is active.
             acceptor_up.reset();
         }
         platform.SetConnection (conn);
 
         if (platform.IsConnected())
         {
+            if (inferior_arguments.GetArgumentCount() > 0)
+            {
+                lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
+                uint16_t port = 0;
+                std::string socket_name;
+                Error error = platform.LaunchGDBServer(inferior_arguments,
+                                                       "", // hostname
+                                                       pid,
+                                                       port,
+                                                       socket_name);
+                if (error.Success())
+                    platform.SetPendingGdbServer(pid, port, socket_name);
+                else
+                    fprintf(stderr, "failed to start gdbserver: %s\n", error.AsCString());
+            }
+
             // After we connected, we need to get an initial ack from...
             if (platform.HandshakeWithClient())
             {
                 bool interrupt = false;
                 bool done = false;
                 while (!interrupt && !done)
                 {
                     if (platform.GetPacketAndSendResponse (UINT32_MAX, error, interrupt, done) != GDBRemoteCommunication::PacketResult::Success)