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

2040–2041

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

2040–2041

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

203

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

990–991

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

183–184

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

203

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.

include/lldb/Target/Platform.h

//                Error &error) = 0;
         //------------------------------------------------------------------
         /// Allow the platform to set preferred memory cache line size. If non-zero (and the user
         /// has not set cache line size explicitly), this value will be used as the cache line
         /// size for memory reads.
         //------------------------------------------------------------------
         virtual uint32_t
         GetDefaultMemoryCacheLineSize() { return 0; }
 
+        virtual Error
+        LaunchRemoteGdbServer(lldb::pid_t &pid, std::string &connect_url)
+        {
+            return Error ("Not implemented");
+        }
+
     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 process 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);            
             }
             else
             {
                 result.AppendErrorWithFormat ("%s\n", error.AsCString());
                 result.SetStatus (eReturnStatusFailed);            
             }
         }
         else
         {
             result.AppendError ("no platform is currently selected\n");
             result.SetStatus (eReturnStatusFailed);            
         }
         return result.Succeeded();
     }
     
     Options *
     GetOptions () override
     {
         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
         OptionGroupOptions* m_platform_options = NULL;
         if (platform_sp)
         {
             m_platform_options = platform_sp->GetConnectionOptions(m_interpreter);
             if (m_platform_options != NULL && !m_platform_options->m_did_finalize)
                 m_platform_options->Finalize();
DoExecute (Args& args, CommandReturnObject &result) override
             result.AppendError ("no platform currently selected\n");
             result.SetStatus (eReturnStatusFailed);
         }
         return result.Succeeded();
     }
 };
 
 //----------------------------------------------------------------------
+// "platform process connect <connect-url>"
+//----------------------------------------------------------------------
+class CommandObjectPlatformProcessConnect : public CommandObjectParsed
+{
+public:
+    CommandObjectPlatformProcessConnect (CommandInterpreter &interpreter) :
+        CommandObjectParsed (interpreter, 
+                             "platform process connect",
+                             "Connect to a remote platform with a pre-specified inferior launch config.",
+                             "platform process connect <connect-url>",
+                             0)
+    {
+    }
+
+    ~CommandObjectPlatformProcessConnect () override = default;
+
+protected:
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
+    {
+        Stream &ostrm = result.GetOutputStream();      
+
+        PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
+        if (!platform_sp)
+        {
+            result.AppendError ("no platform is currently selected\n");
+            result.SetStatus (eReturnStatusFailed);
+            return false;
+        }
+
+        Error error (platform_sp->ConnectRemote (args));
+        if (error.Fail())
+        {
+            result.AppendErrorWithFormat ("%s\n", error.AsCString());
+            result.SetStatus (eReturnStatusFailed);
+            return false;
+        }
+
+        platform_sp->GetStatus (ostrm);
+
+        lldb::pid_t pid = 0;
+        std::string connect_url;
+        error = platform_sp->LaunchRemoteGdbServer(pid, connect_url);
+        if (error.Fail())
+        {
+            result.AppendErrorWithFormat ("%s\n", error.AsCString());
+            result.SetStatus (eReturnStatusFailed);
+            return false;
+        }
+
+        StreamString command;
+        command.Printf("process connect %s", connect_url.c_str());
+        return m_interpreter.HandleCommand(command.GetData(), LazyBool::eLazyBoolNo, result);
+    }
+
+    Options *
+    GetOptions () override
+    {
+        PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
+        OptionGroupOptions* m_platform_options = NULL;
+        if (platform_sp)
+        {
+            m_platform_options = platform_sp->GetConnectionOptions(m_interpreter);
+            if (m_platform_options != NULL && !m_platform_options->m_did_finalize)
+                m_platform_options->Finalize();
+        }
+        return m_platform_options;
+    }
+};
+
+//----------------------------------------------------------------------
 // "platform process launch"
 //----------------------------------------------------------------------
 class CommandObjectPlatformProcessLaunch : public CommandObjectParsed
 {
 public:
     CommandObjectPlatformProcessLaunch (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "platform process launch",

 {
 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] ...")
+                                "platform process [<command-options>]")
     {
-        LoadSubCommand ("attach", CommandObjectSP (new CommandObjectPlatformProcessAttach (interpreter)));
-        LoadSubCommand ("launch", CommandObjectSP (new CommandObjectPlatformProcessLaunch (interpreter)));
-        LoadSubCommand ("info"  , CommandObjectSP (new CommandObjectPlatformProcessInfo (interpreter)));
-        LoadSubCommand ("list"  , CommandObjectSP (new CommandObjectPlatformProcessList (interpreter)));
-
+        LoadSubCommand ("attach" , CommandObjectSP (new CommandObjectPlatformProcessAttach (interpreter)));
+        LoadSubCommand ("connect", CommandObjectSP (new CommandObjectPlatformProcessConnect (interpreter)));
+        LoadSubCommand ("launch" , CommandObjectSP (new CommandObjectPlatformProcessLaunch (interpreter)));
+        LoadSubCommand ("info"   , CommandObjectSP (new CommandObjectPlatformProcessInfo (interpreter)));
+        LoadSubCommand ("list"   , CommandObjectSP (new CommandObjectPlatformProcessList (interpreter)));
     }
-    
-    ~CommandObjectPlatformProcess () override
-    {
-    }
-    
+    ~CommandObjectPlatformProcess () override = default;
 private:
     //------------------------------------------------------------------
     // For CommandObjectPlatform only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (CommandObjectPlatformProcess);
 };
 
 //----------------------------------------------------------------------

source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.h

public:
     Error
     DisconnectRemote () 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;
+    Error
+    LaunchRemoteGdbServer (lldb::pid_t &pid, std::string &connect_url) override;
 
     bool
     KillSpawnedProcess (lldb::pid_t pid) override;
 
     void
     DeleteForwardPort (lldb::pid_t pid);
 
     Error

source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp

 }
 
 PlatformAndroidRemoteGDBServer::~PlatformAndroidRemoteGDBServer ()
 {
     for (const auto& it : m_port_forwards)
         DeleteForwardPortWithAdb(it.second, m_device_id);
 }
 
-bool
-PlatformAndroidRemoteGDBServer::LaunchGDBServer (lldb::pid_t &pid, std::string &connect_url)
+Error
+PlatformAndroidRemoteGDBServer::LaunchRemoteGdbServer (lldb::pid_t &pid, std::string &connect_url)
 {
     uint16_t remote_port = 0;
     std::string socket_name;
     if (!m_gdb_client.LaunchGDBServer ("127.0.0.1", pid, remote_port, socket_name))
-        return false;
+        return Error("Failed to launch gdbserver on the remote host");
 
     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
 
     auto error = MakeConnectURL (pid,
                                  remote_port,
                                  socket_name.c_str (),
                                  connect_url);
     if (error.Success() && log)
         log->Printf("gdbserver connect URL: %s", connect_url.c_str());
 
-    return error.Success();
+    return error;
 }
 
 bool
 PlatformAndroidRemoteGDBServer::KillSpawnedProcess (lldb::pid_t pid)
 {
     DeleteForwardPort (pid);
     return m_gdb_client.KillSpawnedProcess (pid);
 }

source/Plugins/Platform/POSIX/PlatformPOSIX.h

public:
     CalculateTrapHandlerSymbolNames () override;
 
     lldb_private::Error
     ConnectRemote (lldb_private::Args& args) override;
 
     lldb_private::Error
     DisconnectRemote () override;
 
+    lldb_private::Error
+    LaunchRemoteGdbServer(lldb::pid_t &pid, std::string &connect_url) 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
-    
 private:
     DISALLOW_COPY_AND_ASSIGN (PlatformPOSIX);
 };
 
 #endif // liblldb_PlatformPOSIX_h_

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

else
             error.SetErrorString ("the platform is not currently connected");
     }
     return process_sp;
 
 }
 
 void
 PlatformPOSIX::CalculateTrapHandlerSymbolNames ()
-{   
+{
     m_trap_handlers.push_back (ConstString ("_sigtramp"));
-}   
+}
+
+Error
+PlatformPOSIX::LaunchRemoteGdbServer (lldb::pid_t &pid, std::string &connect_url)
+{
+    if (IsHost())
+        return Error("Not supported during local debugging");
+    if (!m_remote_platform_sp)
+        return Error("The platform currently isn't connected");
+    return m_remote_platform_sp->LaunchRemoteGdbServer(pid, connect_url);
+}

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;
 
+    // Launch the debug server on the remote host - caller connects to launched
+    // debug server using connect_url.
+    // Subclasses should override this method if they want to do extra actions before or
+    // after launching the debug server.
+    Error
+    LaunchRemoteGdbServer (lldb::pid_t &pid, std::string &connect_url) override;
+
 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;
 
-    // Launch the debug server on the remote host - caller connects to launched
-    // debug server using connect_url.
-    // Subclasses should override this method if they want to do extra actions before or
-    // after launching the debug server.
-    virtual bool
-    LaunchGDBServer (lldb::pid_t &pid, std::string &connect_url);
 
     virtual bool
     KillSpawnedProcess (lldb::pid_t pid);
 
     virtual std::string
     MakeUrl(const char* scheme,
             const char* hostname,
             uint16_t port,

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

 {
     lldb::ProcessSP process_sp;
     if (IsRemote())
     {
         if (IsConnected())
         {
             lldb::pid_t debugserver_pid = LLDB_INVALID_PROCESS_ID;
             std::string connect_url;
-            if (!LaunchGDBServer(debugserver_pid, connect_url))
+            if (LaunchRemoteGdbServer(debugserver_pid, connect_url).Fail())
             {
                 error.SetErrorStringWithFormat ("unable to launch a GDB server on '%s'", GetHostname ());
             }
             else
             {
                 if (target == NULL)
                 {
                     TargetSP new_target_sp;
if (IsRemote())
         {
             error.SetErrorString("not connected to remote gdb server");
         }
     }
     return process_sp;
 
 }
 
-bool
-PlatformRemoteGDBServer::LaunchGDBServer (lldb::pid_t &pid, std::string &connect_url)
+Error
+PlatformRemoteGDBServer::LaunchRemoteGdbServer (lldb::pid_t &pid, std::string &connect_url)
 {
     ArchSpec remote_arch = GetRemoteSystemArchitecture ();
     llvm::Triple &remote_triple = remote_arch.GetTriple ();
 
     uint16_t port = 0;
     std::string socket_name;
     bool launch_result = false;
     if (remote_triple.getVendor () == llvm::Triple::Apple && remote_triple.getOS () == llvm::Triple::IOS)
     {
         // When remote debugging to iOS, we use a USB mux that always talks
         // to localhost, so we will need the remote debugserver to accept connections
         // only from localhost, no matter what our current hostname is
         launch_result = m_gdb_client.LaunchGDBServer ("127.0.0.1", pid, port, socket_name);
     }
     else
     {
         // All other hosts should use their actual hostname
         launch_result = m_gdb_client.LaunchGDBServer (nullptr, pid, port, socket_name);
     }
 
     if (!launch_result)
-        return false;
+        return Error("Failed to launch gdbserver on the remote host");
 
     connect_url = MakeGdbServerUrl(m_platform_scheme,
                                    m_platform_hostname,
                                    port,
                                    (socket_name.empty()) ? nullptr : socket_name.c_str());
-    return true;
+    return Error();
 }
 
 bool
 PlatformRemoteGDBServer::KillSpawnedProcess (lldb::pid_t pid)
 {
     return m_gdb_client.KillSpawnedProcess (pid);
 }
 
 lldb::ProcessSP
 PlatformRemoteGDBServer::Attach (ProcessAttachInfo &attach_info,
                                  Debugger &debugger,
                                  Target *target,       // Can be NULL, if NULL create a new target, else use existing one
                                  Error &error)
 {
     lldb::ProcessSP process_sp;
     if (IsRemote())
     {
         if (IsConnected())
         {
             lldb::pid_t debugserver_pid = LLDB_INVALID_PROCESS_ID;
             std::string connect_url;
-            if (!LaunchGDBServer(debugserver_pid, connect_url))
+            if (LaunchRemoteGdbServer(debugserver_pid, connect_url).Fail())
             {
                 error.SetErrorStringWithFormat ("unable to launch a GDB server on '%s'", GetHostname ());
             }
             else
             {
                 if (target == NULL)
                 {
                     TargetSP new_target_sp;

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/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);
+
 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;
+    lldb_private::Args m_inferior_arguments;
 
     PacketResult
     Handle_qLaunchGDBServer (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_qKillSpawnedProcess (StringExtractorGDBRemote &packet);
 
     PacketResult

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

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);
+                                           port_ptr,
+                                           m_inferior_arguments);
 
     lldb::pid_t debugserver_pid = debugserver_launch_info.GetProcessID();
 
 
     if (debugserver_pid != LLDB_INVALID_PROCESS_ID)
     {
         Mutex::Locker locker (m_spawned_pids_mutex);
         m_spawned_pids.insert(debugserver_pid);
if (error.Success())
         {
             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)
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::SetInferiorArguments(const Args& args)
+{
+    m_inferior_arguments = args;
+}

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())
if (socket_file)
             fprintf(stderr, "failed to write socket id to %s: %s", socket_file.GetPath().c_str(), error.AsCString());
             return 1;
         }
     }
 
     do {
         GDBRemoteCommunicationServerPlatform platform(acceptor_up->GetSocketProtocol(),
                                                       acceptor_up->GetSocketScheme());
-        
+        if (inferior_arguments.GetArgumentCount() > 0)
+            platform.SetInferiorArguments(inferior_arguments);
         if (port_offset > 0)
             platform.SetPortOffset(port_offset);
 
         if (!gdbserver_portmap.empty())
         {
             platform.SetPortMap(std::move(gdbserver_portmap));
         }