Refactor GdbRemote test cases to support remote platforms

[tberghammer]

Summary

Refactor GdbRemote test cases to support remote platforms

Previously these test cases execute lldb-server on the host and run the tests against it even if a remote platform was specified. With this CL these tests always test the communication with an lldb-server instance running on the target.

[clayborg]

You shouldn't ever have to call SBPlatform::Install() manually unless you just want to run a process remotely without debugging it. Is this what you are trying to do? Install something so that lldb-server can be used? If so ignore what I am saying below.

If you are trying to just debug something remotely, you should be able to connect to the remote platform and it will of course launch lldb-server for you and you should follow the rules below:

The idea with the current SBPlatform and debugging a remote process is:
1 - The main executable will always be installed in the remote working directory unless you set the remote install file spec (see below)
2 - Get a SBModule you want to have uploaded from your target by either finding it, or adding it to the target using SBTarget::AddModule(...) and then call SBModule::SetRemoteInstallFileSpec (lldb::SBFileSpec &file) on any module that you want to ensure is installed by giving the remote path.
3 - When the process is launched, it will iterate through all modules in a target and check for a remote install file spec and anything that has it will be installed to the desired location, and of course the main executable always gets installed. This happens in:

Error
Target::Install (ProcessLaunchInfo *launch_info)

So check your code to make sure it isn't the above case where you just want to remote debug a process and where there is already code that can do the auto-install stuff for you.

[tberghammer]

As far as I know spawnSubprocess() generally used in test cases where lldb (LLGS) attach to an already running process, where the Install is necessary.

In this patch I address issues related to test cases testing the gdb protocol of LLGS with launching it on the target and then connecting to it with a socket. I use the spawnSubprocess() to start LLGS (in gdbserver mode) before connecting to it from python.

The option to disable the installation of the specified executable by spawSubprocess is required, because I have to start the same process as lldb-platform (actually lldb-server) and it can be too big to transfer it over to the remote target (~35 MB release, ~850 MB debug).

[tberghammer]

test/tools/lldb-server/gdbremote_testcase.py

363 ↗

(On Diff #21575)

SBPlatform::Install used here also, but I think it is impossible to avoid, because these tests are testing LLGS in a lower level with sending packets directly to it.
The logic you mentioned is executed only when we do a "run" or a "process launch" command in lldb what isn't happening here. The inferior is launched with sending an $A packet directly to LLGS from python with skipping the logic surrounding it in lldb.

[clayborg]

Thanks for the explanation. Looks good.

lldb/trunk/test/lldbtest.py

def launch(self, executable, args):
         self._proc = Popen([executable] + args,
                            stdout = open(os.devnull) if not self._trace_on else None,
                            stdin = PIPE)
 
     def terminate(self):
         if self._proc.poll() == None:
             self._proc.terminate()
 
+    def poll(self):
+        return self._proc.poll()
+
 class _RemoteProcess(_BaseProcess):
 
-    def __init__(self):
+    def __init__(self, install_remote):
         self._pid = None
+        self._install_remote = install_remote
 
     @property
     def pid(self):
         return self._pid
 
     def launch(self, executable, args):
         remote_work_dir = lldb.remote_platform.GetWorkingDirectory()
+
+        if self._install_remote:
             src_path = executable
             dst_path = os.path.join(remote_work_dir, os.path.basename(executable))
 
             dst_file_spec = lldb.SBFileSpec(dst_path, False)
-        err = lldb.remote_platform.Install(lldb.SBFileSpec(src_path, True),
-                                           dst_file_spec)
+            err = lldb.remote_platform.Install(lldb.SBFileSpec(src_path, True), dst_file_spec)
             if err.Fail():
                 raise Exception("remote_platform.Install('%s', '%s') failed: %s" % (src_path, dst_path, err))
+        else:
+            dst_path = executable
+            dst_file_spec = lldb.SBFileSpec(executable, False)
 
         launch_info = lldb.SBLaunchInfo(args)
         launch_info.SetExecutableFile(dst_file_spec, True)
         launch_info.SetWorkingDirectory(remote_work_dir)
 
         # Redirect stdout and stderr to /dev/null
         launch_info.AddSuppressFileAction(1, False, True)
         launch_info.AddSuppressFileAction(2, False, True)
 
         err = lldb.remote_platform.Launch(launch_info)
         if err.Fail():
             raise Exception("remote_platform.Launch('%s', '%s') failed: %s" % (dst_path, args, err))
         self._pid = launch_info.GetProcessID()
 
     def terminate(self):
-        err = lldb.remote_platform.Kill(self._pid)
-        if err.Fail():
-            raise Exception("remote_platform.Kill(%d) failed: %s" % (self._pid, err))
+        lldb.remote_platform.Kill(self._pid)
 
 # From 2.7's subprocess.check_output() convenience function.
 # Return a tuple (stdoutdata, stderrdata).
 def system(commands, **kwargs):
     r"""Run an os command with arguments and return its output as a byte string.
 
     If the exit code was non-zero it raises a CalledProcessError.  The
     CalledProcessError object will have the return code in the returncode
def cleanupSubprocesses(self):
             p.terminate()
             del p
         del self.subprocesses[:]
         # Ensure any forked processes are cleaned up
         for pid in self.forkedProcessPids:
             if os.path.exists("/proc/" + str(pid)):
                 os.kill(pid, signal.SIGTERM)
 
-    def spawnSubprocess(self, executable, args=[]):
+    def spawnSubprocess(self, executable, args=[], install_remote=True):
         """ Creates a subprocess.Popen object with the specified executable and arguments,
             saves it in self.subprocesses, and returns the object.
             NOTE: if using this function, ensure you also call:
 
               self.addTearDownHook(self.cleanupSubprocesses)
 
             otherwise the test suite will leak processes.
         """
-        proc = _RemoteProcess() if lldb.remote_platform else _LocalProcess(self.TraceOn())
+        proc = _RemoteProcess(install_remote) if lldb.remote_platform else _LocalProcess(self.TraceOn())
         proc.launch(executable, args)
         self.subprocesses.append(proc)
         return proc
 
     def forkSubprocess(self, executable, args=[]):
         """ Fork a subprocess with its own group ID.
             NOTE: if using this function, ensure you also call:
 

lldb/trunk/test/tools/lldb-server/TestGdbRemoteKill.py

def attach_commandline_kill_after_initial_stop(self):
                 {"direction":"send", "regex":r"^\$X[0-9a-fA-F]+([^#]*)#[0-9A-Fa-f]{2}" },
                 ], True)
 
         self.expect_gdbremote_sequence()
 
         # Wait a moment for completed and now-detached inferior process to clear.
         time.sleep(1)
 
-        # Process should be dead now.  Reap results.
+        if not lldb.remote_platform:
+            # Process should be dead now. Reap results.
             poll_result = procs["inferior"].poll()
             self.assertIsNotNone(poll_result)
 
         # Where possible, verify at the system level that the process is not running.
         self.assertFalse(lldbgdbserverutils.process_is_running(procs["inferior"].pid, False))
 
     @debugserver_test
     @dsym_test
     def test_attach_commandline_kill_after_initial_stop_debugserver_dsym(self):
         self.init_debugserver_test()

lldb/trunk/test/tools/lldb-server/TestLldbGdbServer.py

def test_list_threads_in_stop_reply_supported_debugserver(self):
         self.init_debugserver_test()
         self.list_threads_in_stop_reply_supported()
 
     @llgs_test
     def test_list_threads_in_stop_reply_supported_llgs(self):
         self.init_llgs_test()
         self.list_threads_in_stop_reply_supported()
 
+    def install_and_create_launch_args(self):
+        exe_path = os.path.abspath('a.out')
+        if not lldb.remote_platform:
+            return [exe_path]
+        remote_work_dir = lldb.remote_platform.GetWorkingDirectory()
+        remote_path = os.path.join(remote_work_dir, os.path.basename(exe_path))
+        remote_file_spec = lldb.SBFileSpec(remote_path, False)
+        err = lldb.remote_platform.Install(lldb.SBFileSpec(exe_path, True), remote_file_spec)
+        if err.Fail():
+            raise Exception("remote_platform.Install('%s', '%s') failed: %s" % (exe_path, remote_path, err))
+        return [remote_path]
+
     def start_inferior(self):
+        launch_args = self.install_and_create_launch_args()
+
         server = self.connect_to_debug_monitor()
         self.assertIsNotNone(server)
 
-        # build launch args
-        launch_args = [os.path.abspath('a.out')]
         self.add_no_ack_remote_stream()
         self.test_sequence.add_log_lines(
             ["read packet: %s" % lldbgdbserverutils.build_gdbremote_A_packet(launch_args),
              "send packet: $OK#9a"],
             True)
         self.expect_gdbremote_sequence()
 
     @debugserver_test
     @dsym_test
     def test_start_inferior_debugserver_dsym(self):
         self.init_debugserver_test()
         self.buildDsym()
         self.start_inferior()
 
     @llgs_test
     @dwarf_test
     def test_start_inferior_llgs_dwarf(self):
         self.init_llgs_test()
         self.buildDwarf()
         self.start_inferior()
 
     def inferior_exit_0(self):
+        launch_args = self.install_and_create_launch_args()
+
         server = self.connect_to_debug_monitor()
         self.assertIsNotNone(server)
 
-        # build launch args
-        launch_args = [os.path.abspath('a.out')]
-
         self.add_no_ack_remote_stream()
         self.add_verified_launch_packets(launch_args)
         self.test_sequence.add_log_lines(
             ["read packet: $vCont;c#a8",
              "send packet: $W00#00"],
             True)
 
         self.expect_gdbremote_sequence()
 
     @debugserver_test
     @dsym_test
     def test_inferior_exit_0_debugserver_dsym(self):
         self.init_debugserver_test()
         self.buildDsym()
         self.inferior_exit_0()
 
     @llgs_test
     @dwarf_test
     def test_inferior_exit_0_llgs_dwarf(self):
         self.init_llgs_test()
         self.buildDwarf()
         self.inferior_exit_0()
 
     def inferior_exit_42(self):
+        launch_args = self.install_and_create_launch_args()
+
         server = self.connect_to_debug_monitor()
         self.assertIsNotNone(server)
 
         RETVAL = 42
 
         # build launch args
-        launch_args = [os.path.abspath('a.out'), "retval:%d" % RETVAL]
+        launch_args += ["retval:%d" % RETVAL]
 
         self.add_no_ack_remote_stream()
         self.add_verified_launch_packets(launch_args)
         self.test_sequence.add_log_lines(
             ["read packet: $vCont;c#a8",
              "send packet: $W{0:02x}#00".format(RETVAL)],
             True)
 
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase):
     @llgs_test
     @dwarf_test
     def test_inferior_exit_42_llgs_dwarf(self):
         self.init_llgs_test()
         self.buildDwarf()
         self.inferior_exit_42()
 
     def c_packet_works(self):
+        launch_args = self.install_and_create_launch_args()
+
         server = self.connect_to_debug_monitor()
         self.assertIsNotNone(server)
 
-        # build launch args
-        launch_args = [os.path.abspath('a.out')]
-
         self.add_no_ack_remote_stream()
         self.add_verified_launch_packets(launch_args)
         self.test_sequence.add_log_lines(
             ["read packet: $c#63",
              "send packet: $W00#00"],
             True)
 
         self.expect_gdbremote_sequence()
 
     @debugserver_test
     @dsym_test
     def test_c_packet_works_debugserver_dsym(self):
         self.init_debugserver_test()
         self.buildDsym()
         self.c_packet_works()
 
     @llgs_test
     @dwarf_test
     def test_c_packet_works_llgs_dwarf(self):
         self.init_llgs_test()
         self.buildDwarf()
         self.c_packet_works()
 
     def inferior_print_exit(self):
+        launch_args = self.install_and_create_launch_args()
+
         server = self.connect_to_debug_monitor()
         self.assertIsNotNone(server)
 
         # build launch args
-        launch_args = [os.path.abspath('a.out'), "hello, world"]
+        launch_args += ["hello, world"]
 
         self.add_no_ack_remote_stream()
         self.add_verified_launch_packets(launch_args)
         self.test_sequence.add_log_lines(
             ["read packet: $vCont;c#a8",
              {"type":"output_match", "regex":r"^hello, world\r\n$" },
              "send packet: $W00#00"],
             True)
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase):
     @llgs_test
     @dwarf_test
     def test_inferior_print_exit_llgs_dwarf(self):
         self.init_llgs_test()
         self.buildDwarf()
         self.inferior_print_exit()
 
     def first_launch_stop_reply_thread_matches_first_qC(self):
+        launch_args = self.install_and_create_launch_args()
+
         server = self.connect_to_debug_monitor()
         self.assertIsNotNone(server)
 
         # build launch args
-        launch_args = [os.path.abspath('a.out'), "hello, world"]
+        launch_args += ["hello, world"]
 
         self.add_no_ack_remote_stream()
         self.add_verified_launch_packets(launch_args)
         self.test_sequence.add_log_lines(
             ["read packet: $qC#00",
              { "direction":"send", "regex":r"^\$QC([0-9a-fA-F]+)#", "capture":{1:"thread_id"} },
              "read packet: $?#00",
              { "direction":"send", "regex":r"^\$T[0-9a-fA-F]{2}thread:([0-9a-fA-F]+)", "expect_captures":{1:"thread_id"} }],
def attach_commandline_continue_app_exits(self):
             ["read packet: $vCont;c#a8",
              "send packet: $W00#00"],
             True)
         self.expect_gdbremote_sequence()
 
         # Wait a moment for completed and now-detached inferior process to clear.
         time.sleep(1)
 
-        # Process should be dead now.  Reap results.
+        if not lldb.remote_platform:
+            # Process should be dead now. Reap results.
             poll_result = procs["inferior"].poll()
             self.assertIsNotNone(poll_result)
 
         # Where possible, verify at the system level that the process is not running.
         self.assertFalse(lldbgdbserverutils.process_is_running(procs["inferior"].pid, False))
 
     @debugserver_test
     @dsym_test
     def test_attach_commandline_continue_app_exits_debugserver_dsym(self):
         self.init_debugserver_test()
         self.buildDsym()
         self.set_inferior_startup_attach()
         self.attach_commandline_continue_app_exits()
 
     @llgs_test
     @dwarf_test
     def test_attach_commandline_continue_app_exits_llgs_dwarf(self):
         self.init_llgs_test()
         self.buildDwarf()
         self.set_inferior_startup_attach()
         self.attach_commandline_continue_app_exits()
 
     def qRegisterInfo_returns_one_valid_result(self):
+        launch_args = self.install_and_create_launch_args()
+
         server = self.connect_to_debug_monitor()
         self.assertIsNotNone(server)
 
-        # Build launch args
-        launch_args = [os.path.abspath('a.out')]
-
         # Build the expected protocol stream
         self.add_no_ack_remote_stream()
         self.add_verified_launch_packets(launch_args)
         self.test_sequence.add_log_lines(
             ["read packet: $qRegisterInfo0#00",
              { "direction":"send", "regex":r"^\$(.+);#[0-9A-Fa-f]{2}", "capture":{1:"reginfo_0"} }],
             True)
 
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase):
     @llgs_test
     @dwarf_test
     def test_qRegisterInfo_returns_one_valid_result_llgs_dwarf(self):
         self.init_llgs_test()
         self.buildDwarf()
         self.qRegisterInfo_returns_one_valid_result()
 
     def qRegisterInfo_returns_all_valid_results(self):
+        launch_args = self.install_and_create_launch_args()
+
         server = self.connect_to_debug_monitor()
         self.assertIsNotNone(server)
 
-        # Build launch args.
-        launch_args = [os.path.abspath('a.out')]
-
         # Build the expected protocol stream.
         self.add_no_ack_remote_stream()
         self.add_verified_launch_packets(launch_args)
         self.add_register_info_collection_packets()
 
         # Run the stream.
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase):
     @llgs_test
     @dwarf_test
     def test_qRegisterInfo_returns_all_valid_results_llgs_dwarf(self):
         self.init_llgs_test()
         self.buildDwarf()
         self.qRegisterInfo_returns_all_valid_results()
 
     def qRegisterInfo_contains_required_generics(self):
+        launch_args = self.install_and_create_launch_args()
+
         server = self.connect_to_debug_monitor()
         self.assertIsNotNone(server)
 
-        # Build launch args
-        launch_args = [os.path.abspath('a.out')]
-
         # Build the expected protocol stream
         self.add_no_ack_remote_stream()
         self.add_verified_launch_packets(launch_args)
         self.add_register_info_collection_packets()
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase):
     @llgs_test
     @dwarf_test
     def test_qRegisterInfo_contains_required_generics_llgs_dwarf(self):
         self.init_llgs_test()
         self.buildDwarf()
         self.qRegisterInfo_contains_required_generics()
 
     def qRegisterInfo_contains_at_least_one_register_set(self):
+        launch_args = self.install_and_create_launch_args()
+
         server = self.connect_to_debug_monitor()
         self.assertIsNotNone(server)
 
-        # Build launch args
-        launch_args = [os.path.abspath('a.out')]
-
         # Build the expected protocol stream
         self.add_no_ack_remote_stream()
         self.add_verified_launch_packets(launch_args)
         self.add_register_info_collection_packets()
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase):
     @llgs_test
     @dwarf_test
     def test_qRegisterInfo_contains_at_least_one_register_set_llgs_dwarf(self):
         self.init_llgs_test()
         self.buildDwarf()
         self.qRegisterInfo_contains_at_least_one_register_set()
 
     def qRegisterInfo_contains_avx_registers_on_linux_x86_64(self):
+        launch_args = self.install_and_create_launch_args()
+
         server = self.connect_to_debug_monitor()
         self.assertIsNotNone(server)
 
-        # Build launch args
-        launch_args = [os.path.abspath('a.out')]
-
         # Build the expected protocol stream
         self.add_no_ack_remote_stream()
         self.add_verified_launch_packets(launch_args)
         self.add_register_info_collection_packets()
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)

lldb/trunk/test/tools/lldb-server/commandline/TestStubReverseConnect.py

 # Add the directory above ours to the python library path since we
 # will import from there.
 import os.path
 import sys
 sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
 
 import gdbremote_testcase
+import lldbgdbserverutils
 import re
 import select
 import socket
 import time
 from lldbtest import *
 
 class TestStubReverseConnect(gdbremote_testcase.GdbRemoteTestCaseBase):
     _DEFAULT_TIMEOUT = 20
def create_listener_socket(self, timeout_seconds=_DEFAULT_TIMEOUT):
                 # ignore
                 None
 
         self.addTearDownHook(tear_down_listener)
         return sock
 
     def reverse_connect_works(self):
         # Indicate stub startup should do a reverse connect.
-        appended_stub_args = " --reverse-connect"
+        appended_stub_args = ["--reverse-connect"]
         if self.debug_monitor_extra_args:
             self.debug_monitor_extra_args += appended_stub_args
         else:
             self.debug_monitor_extra_args = appended_stub_args
 
         self.stub_hostname = "127.0.0.1"
         self.port = self.listener_port
 
         # Start the stub.
         server = self.launch_debug_monitor(logfile=sys.stdout)
         self.assertIsNotNone(server)
-        self.assertTrue(server.isalive())
+        self.assertTrue(lldbgdbserverutils.process_is_running(server.pid, True))
 
         # Listen for the stub's connection to us.
         (stub_socket, address) = self.listener_socket.accept()
         self.assertIsNotNone(stub_socket)
         self.assertIsNotNone(address)
         print "connected to stub {} on {}".format(address, stub_socket.getsockname())
 
         # Verify we can do the handshake.  If that works, we'll call it good.

lldb/trunk/test/tools/lldb-server/commandline/TestStubSetSID.py

 import unittest2
 
 # Add the directory above ours to the python library path since we
 # will import from there.
 import os.path
 import sys
 sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
 
 import gdbremote_testcase
+import lldbgdbserverutils
 import os
 import select
 import tempfile
 import time
 from lldbtest import *
 
-
-def get_common_stub_args():
-    return [] if 'darwin' in sys.platform else ['g']
-
-
 class TestStubSetSIDTestCase(gdbremote_testcase.GdbRemoteTestCaseBase):
     def get_stub_sid(self, extra_stub_args=None):
         # Launch debugserver
         if extra_stub_args:
-            self.debug_monitor_extra_args = extra_stub_args
-        else:
-            self.debug_monitor_extra_args = ""
+            self.debug_monitor_extra_args += extra_stub_args
 
         server = self.launch_debug_monitor()
         self.assertIsNotNone(server)
-        self.assertTrue(server.isalive())
-        server.expect("(debugserver|lldb-server)", timeout=10)
+        self.assertTrue(lldbgdbserverutils.process_is_running(server.pid, True))
 
         # Get the process id for the stub.
         return os.getsid(server.pid)
 
     def sid_is_same_without_setsid(self):
         stub_sid = self.get_stub_sid()
         self.assertEquals(stub_sid, os.getsid(0))
 
     def sid_is_different_with_setsid(self):
-        stub_sid = self.get_stub_sid(" %s --setsid" % ' '.join(get_common_stub_args()))
+        stub_sid = self.get_stub_sid(["--setsid"])
         self.assertNotEquals(stub_sid, os.getsid(0))
 
     def sid_is_different_with_S(self):
-        stub_sid = self.get_stub_sid(" %s -S" % ' '.join(get_common_stub_args()))
+        stub_sid = self.get_stub_sid(["-S"])
         self.assertNotEquals(stub_sid, os.getsid(0))
 
     @debugserver_test
     @unittest2.expectedFailure() # This is the whole purpose of this feature, I would expect it to be the same without --setsid. Investigate.
     def test_sid_is_same_without_setsid_debugserver(self):
         self.init_debugserver_test()
         self.set_inferior_startup_launch()
         self.sid_is_same_without_setsid()

lldb/trunk/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:
+            # Remote platforms don't support named pipe based port negotiation
+            use_named_pipe = False
+
+            platform = self.dbg.GetSelectedPlatform()
+
+            shell_command = lldb.SBPlatformShellCommand("echo $PPID")
+            err = platform.Run(shell_command)
+            if err.Fail():
+                raise Exception("remote_platform.RunShellCommand('echo $PPID') failed: %s" % err)
+            pid = shell_command.GetOutput().strip()
+
+            shell_command = lldb.SBPlatformShellCommand("readlink /proc/%s/exe" % pid)
+            err = platform.Run(shell_command)
+            if err.Fail():
+                raise Exception("remote_platform.RunShellCommand('readlink /proc/%d/exe') failed: %s" % (pid, err))
+            self.debug_monitor_exe = shell_command.GetOutput().strip()
+            dname = self.dbg.GetSelectedPlatform().GetWorkingDirectory()
+        else:
             self.debug_monitor_exe = get_lldb_server_exe()
             if not self.debug_monitor_exe:
                 self.skipTest("lldb-server exe not found")
-        dname = os.path.join(os.environ["LLDB_TEST"],
-                             os.environ["LLDB_SESSION_DIRNAME"])
-        self.debug_monitor_extra_args = " gdbserver -c 'log enable -T -f {}/process-{}.log lldb break process thread' -c 'log enable -T -f {}/packets-{}.log gdb-remote packets'".format(dname, self.id(), dname, self.id())
+            dname = os.path.join(os.environ["LLDB_TEST"], os.environ["LLDB_SESSION_DIRNAME"])
+
+        self.debug_monitor_extra_args = ["gdbserver", "-c", "log enable -T -f {}/process-{}.log lldb break process thread".format(dname, self.id()), "-c", "log enable -T -f {}/packets-{}.log gdb-remote packets".format(dname, self.id())]
         if use_named_pipe:
             (self.named_pipe_path, self.named_pipe, self.named_pipe_fd) = self.create_named_pipe()
 
     def init_debugserver_test(self, use_named_pipe=True):
         self.debug_monitor_exe = get_debugserver_exe()
         if not self.debug_monitor_exe:
             self.skipTest("debugserver exe not found")
-        self.debug_monitor_extra_args = " --log-file=/tmp/packets-{}.log --log-flags=0x800000".format(self._testMethodName)
+        self.debug_monitor_extra_args = ["--log-file=/tmp/packets-{}.log".format(self._testMethodName), "--log-flags=0x800000"]
         if use_named_pipe:
             (self.named_pipe_path, self.named_pipe, self.named_pipe_fd) = self.create_named_pipe()
         # The debugserver stub has a race on handling the 'k' command, so it sends an X09 right away, then sends the real X notification
         # when the process truly dies.
         self.stub_sends_two_stop_notifications_on_kill = True
 
     def create_socket(self):
         sock = socket.socket()
def create_socket(self):
 
                 try:
                     sock.close()
                 except:
                     logger.warning("failed to close socket to debug monitor: {}; ignoring".format(sys.exc_info()[0]))
 
         self.addTearDownHook(shutdown_socket)
 
+        triple = self.dbg.GetSelectedPlatform().GetTriple()
+        if re.match(".*-.*-.*-android", triple):
+            subprocess.call(["adb", "forward", "tcp:%d" % self.port, "tcp:%d" % self.port])
+            def remove_port_forward():
+                subprocess.call(["adb", "forward", "--remove", "tcp:%d" % self.port])
+
+            self.addTearDownHook(remove_port_forward)
+
         connect_info = (self.stub_hostname, self.port)
         # print "connecting to stub on {}:{}".format(connect_info[0], connect_info[1])
         sock.connect(connect_info)
 
         return sock
 
     def set_inferior_startup_launch(self):
         self._inferior_startup = self._STARTUP_LAUNCH
 
     def set_inferior_startup_attach(self):
         self._inferior_startup = self._STARTUP_ATTACH
 
     def set_inferior_startup_attach_manually(self):
         self._inferior_startup = self._STARTUP_ATTACH_MANUALLY
 
-    def get_debug_monitor_command_line(self, attach_pid=None):
-        commandline = "{}{} localhost:{}".format(self.debug_monitor_exe, self.debug_monitor_extra_args, self.port)
+    def get_debug_monitor_command_line_args(self, attach_pid=None):
+        commandline_args = self.debug_monitor_extra_args + ["localhost:{}".format(self.port)]
         if attach_pid:
-            commandline += " --attach=%d" % attach_pid
+            commandline_args += ["--attach=%d" % attach_pid]
         if self.named_pipe_path:
-            commandline += " --named-pipe %s" % self.named_pipe_path
-        return commandline
+            commandline_args += ["--named-pipe", self.named_pipe_path]
+        return commandline_args
+
+    def run_platform_command(self, cmd):
+        platform = self.dbg.GetSelectedPlatform()
+        shell_command = lldb.SBPlatformShellCommand(cmd)
+        err = platform.Run(shell_command)
+        return (err, shell_command.GetOutput())
 
     def launch_debug_monitor(self, attach_pid=None, logfile=None):
         # Create the command line.
-        import pexpect
-        commandline = self.get_debug_monitor_command_line(attach_pid=attach_pid)
+        commandline_args = self.get_debug_monitor_command_line_args(attach_pid=attach_pid)
 
         # Start the server.
-        server = pexpect.spawn(commandline, logfile=logfile)
+        server = self.spawnSubprocess(self.debug_monitor_exe, commandline_args, install_remote=False)
+        self.addTearDownHook(self.cleanupSubprocesses)
         self.assertIsNotNone(server)
-        server.expect(r"(debugserver|lldb-server)", timeout=10)
 
         # If we're receiving the stub's listening port from the named pipe, do that here.
         if self.named_pipe:
             self.port = self.get_stub_port_from_named_socket()
-            # print "debug server listening on {}".format(self.port)
-
-        # Turn on logging for what the child sends back.
-        if self.TraceOn():
-            server.logfile_read = sys.stdout
 
         return server
 
     def connect_to_debug_monitor(self, attach_pid=None):
         if self.named_pipe:
             # Create the stub.
             server = self.launch_debug_monitor(attach_pid=attach_pid)
             self.assertIsNotNone(server)
 
             def shutdown_debug_monitor():
                 try:
-                    server.close()
+                    server.terminate()
                 except:
                     logger.warning("failed to close pexpect server for debug monitor: {}; ignoring".format(sys.exc_info()[0]))
             self.addTearDownHook(shutdown_debug_monitor)
 
             # Schedule debug monitor to be shut down during teardown.
             logger = self.logger
 
             # Attach to the stub and return a socket opened to it.
             self.sock = self.create_socket()
             return server
 
         # We're using a random port algorithm to try not to collide with other ports,
         # and retry a max # times.
         attempts = 0
         MAX_ATTEMPTS = 20
 
         while attempts < MAX_ATTEMPTS:
             server = self.launch_debug_monitor(attach_pid=attach_pid)
 
-            # Wait until we receive the server ready message before continuing.
-            port_good = True
-            try:
-                server.expect_exact('Listening to port {} for a connection from localhost'.format(self.port))
-            except:
-                port_good = False
-                server.close()
-
-            if port_good:
-                # Schedule debug monitor to be shut down during teardown.
-                logger = self.logger
-                def shutdown_debug_monitor():
-                    try:
-                        server.close()
-                    except:
-                        logger.warning("failed to close pexpect server for debug monitor: {}; ignoring".format(sys.exc_info()[0]))
-                self.addTearDownHook(shutdown_debug_monitor)
+                    server.terminate()
+                    logger.warning("failed to terminate server for debug monitor: {}; ignoring".format(sys.exc_info()[0]))
 
-                # Create a socket to talk to the server
-                try:
-                    self.sock = self.create_socket()
-                    return server
-                except socket.error as serr:
-                    # We're only trying to handle connection refused.
-                    if serr.errno != errno.ECONNREFUSED:
-                        raise serr
-                    # We should close the server here to be safe.
-                    server.close()
+                server.terminate()
 
             # Increment attempts.
             print("connect to debug monitor on port %d failed, attempt #%d of %d" % (self.port, attempts + 1, MAX_ATTEMPTS))
             attempts += 1
 
             # And wait a random length of time before next attempt, to avoid collisions.
             time.sleep(random.randint(1,5))
             
             # Now grab a new port number.
             self.port = self.get_next_port()
 
         raise Exception("failed to create a socket to the launched debug monitor after %d tries" % attempts)
 
-    def launch_process_for_attach(self,inferior_args=None, sleep_seconds=3, exe_path=None):
+    def launch_process_for_attach(self, inferior_args=None, sleep_seconds=3, exe_path=None):
         # We're going to start a child process that the debug monitor stub can later attach to.
         # This process needs to be started so that it just hangs around for a while.  We'll
         # have it sleep.
         if not exe_path:
             exe_path = os.path.abspath("a.out")
 
-        args = [exe_path]
+        args = []
         if inferior_args:
             args.extend(inferior_args)
         if sleep_seconds:
             args.append("sleep:%d" % sleep_seconds)
 
-        return subprocess.Popen(args)
+        return self.spawnSubprocess(exe_path, args)
 
     def prep_debug_monitor_and_inferior(self, inferior_args=None, inferior_sleep_seconds=3, inferior_exe_path=None):
         """Prep the debug monitor, the inferior, and the expected packet stream.
 
         Handle the separate cases of using the debug monitor in attach-to-inferior mode
         and in launch-inferior mode.
 
         For attach-to-inferior mode, the inferior process is first started, then
def prep_debug_monitor_and_inferior(self, inferior_args=None, inferior_sleep_seconds=3, inferior_exe_path=None):
             # Launch the process that we'll use as the inferior.
             inferior = self.launch_process_for_attach(inferior_args=inferior_args, sleep_seconds=inferior_sleep_seconds, exe_path=inferior_exe_path)
             self.assertIsNotNone(inferior)
             self.assertTrue(inferior.pid > 0)
             if self._inferior_startup == self._STARTUP_ATTACH:
                 # In this case, we want the stub to attach via the command line, so set the command line attach pid here.
                 attach_pid = inferior.pid
 
-        # Launch the debug monitor stub, attaching to the inferior.
-        server = self.connect_to_debug_monitor(attach_pid=attach_pid)
-        self.assertIsNotNone(server)
-
         if self._inferior_startup == self._STARTUP_LAUNCH:
             # Build launch args
             if not inferior_exe_path:
                 inferior_exe_path = os.path.abspath("a.out")
+
+            if lldb.remote_platform:
+                remote_work_dir = lldb.remote_platform.GetWorkingDirectory()
+                remote_path = os.path.join(remote_work_dir, os.path.basename(inferior_exe_path))
+                remote_file_spec = lldb.SBFileSpec(remote_path, False)
+                err = lldb.remote_platform.Install(lldb.SBFileSpec(inferior_exe_path, True), remote_file_spec)
+                if err.Fail():
+                    raise Exception("remote_platform.Install('%s', '%s') failed: %s" % (inferior_exe_path, remote_path, err))
+                inferior_exe_path = remote_path
+
             launch_args = [inferior_exe_path]
             if inferior_args:
                 launch_args.extend(inferior_args)
 
+        # Launch the debug monitor stub, attaching to the inferior.
+        server = self.connect_to_debug_monitor(attach_pid=attach_pid)
+        self.assertIsNotNone(server)
+
         # Build the expected protocol stream
         self.add_no_ack_remote_stream()
         if self._inferior_startup == self._STARTUP_LAUNCH:
             self.add_verified_launch_packets(launch_args)
 
         return {"inferior":inferior, "server":server}
 
     def expect_socket_recv(self, sock, expected_content_regex, timeout_seconds):

lldb/trunk/test/tools/lldb-server/lldbgdbserverutils.py

 """Module for supporting unit testing of the lldb-server debug monitor exe.
 """
 
 import os
 import os.path
 import platform
 import Queue
 import re
 import socket_packet_pump
 import subprocess
 import time
+from lldbtest import *
 
 def _get_debug_monitor_from_lldb(lldb_exe, debug_monitor_basename):
     """Return the debug monitor exe path given the lldb exe path.
 
     This method attempts to construct a valid debug monitor exe name
     from a given lldb exe name.  It will return None if the synthesized
     debug monitor name is not found to exist.
 
def process_is_running(pid, unknown_value=True):
     Returns:
 
         If we can figure out how to check running process ids on the given OS:
         return True if the process is running, or False otherwise.
 
         If we don't know how to check running process ids on the given OS:
         return the value provided by the unknown_value arg.
     """
-    if type(pid) != int:
-        raise Exception("pid must be of type int")
+    if type(pid) not in [int, long]:
+        raise Exception("pid must be of type int (actual type: %s)" % str(type(pid)))
 
     process_ids = []
 
-    if platform.system() in ['Darwin', 'Linux', 'FreeBSD', 'NetBSD']:
+    if lldb.remote_platform:
+        # Don't know how to get list of running process IDs on a remote
+        # platform
+        return unknown_value
+    elif platform.system() in ['Darwin', 'Linux', 'FreeBSD', 'NetBSD']:
         # Build the list of running process ids
         output = subprocess.check_output("ps ax | awk '{ print $1; }'", shell=True)
         text_process_ids = output.split('\n')[1:]
         # Convert text pids to ints
         process_ids = [int(text_pid) for text_pid in text_process_ids if text_pid != '']
     # elif {your_platform_here}:
     #   fill in process_ids as a list of int type process IDs running on
     #   the local system.