[lldb] Remove forward-connect ability from lldb-server tests

[labath]

Summary

Forward connections are impossible to set up reliably, which is why the
existing implementation was relying on retries (and crossing fingers).
Reverse connections are reliable and can be used in all situations that
the test suite is currently being used.

To compensate for the loss of forward-connect test coverage, I create a
dedicated test using the forward connection method. It still relies on
retries, but I've tried to make it as robust as I can, and at least it's
just one test instead of the whole test suite.

[DavidSpickett]

Omair can comment on how useful this is for SVE testing.

I do use this to run the memory tagging tests on qemu, we don't have real hardware yet. Let me see what extra steps I need to run them within qemu instead.

[labath]

Thanks for the info. If you are using it then I think we can come up with something would support your use case. TBH, I am kinda surprised this even works (are you sure you're running lldb-*server* tests and not just the "normal" lldb ones?) -- I haven't seen any patches in this area, so I expected it to have bitrotted.

The main thing which is in my way me is the (flaky) forward-connection mode. Would it be ok if we used reverse connections here? I am assuming we don't have to worry about firewalls with qemu..

[DavidSpickett]

I'm running lldb/test/API/tools/lldb-server/memory-tagging/TestGdbRemoteMemoryTagging.py.

If the details matter any...

In qemu:

$ ./build-cross/bin/lldb-server platform --server --listen 0.0.0.0:54321

On the host:

$ ./bin/lldb-dotest --platform-name remote-linux --platform-url connect://<VM IP>:54321 --platform-working-dir /tmp/test_lldb -p TestGdbRemoteMemoryTagging.py --arch aarch64

I have qemu setup so that any port lldb-server picks should be accessible from the host and the VM is just running the usual background linux stuff plus lldb-server. Not a lot to use up ports.

Can you remind me what forward/reverse mean here? I guess that forward is us telling the remote the port to use, which might already be taken on the remote itself. Then reverse is the remote launching the lldb-server on a port it chooses, then telling us what it chose. The latter should be fine for my setup.

[omjavaid]

This doesnt interfere with LLDB tests for SVE. Rather I have not used it in a while for SVE tests I ahve using setup similar to to one David has explained above.

@labath Do you know if android adb based tests are being run anywhere? Are we still maintaining this support and does it work?

[labath]

In D117559#3254095, @DavidSpickett wrote:

I'm running lldb/test/API/tools/lldb-server/memory-tagging/TestGdbRemoteMemoryTagging.py.

If the details matter any...

In qemu:

$ ./build-cross/bin/lldb-server platform --server --listen 0.0.0.0:54321

On the host:

$ ./bin/lldb-dotest --platform-name remote-linux --platform-url connect://<VM IP>:54321 --platform-working-dir /tmp/test_lldb -p TestGdbRemoteMemoryTagging.py --arch aarch64

Got it. Thanks.

I have qemu setup so that any port lldb-server picks should be accessible from the host and the VM is just running the usual background linux stuff plus lldb-server. Not a lot to use up ports.

The tricky part is that even individual parallel test runs (if you run the whole test suite, not just a single test like you did above) can race with each other.

Can you remind me what forward/reverse mean here? I guess that forward is us telling the remote the port to use, which might already be taken on the remote itself.

Correct.

Then reverse is the remote launching the lldb-server on a port it chooses, then telling us what it chose.

Not quite. In "reverse mode" it is the client (in this case -- the test suite) who is choosing a port and listening on it. lldb-server gets an address and it connects to it.

We also have the method which you described (we probably have more connection methods than we should). That one is also reliable (though it gets fuzzy with IPv6, as then the port number alone does not uniquely identify an endpoint), but it has more moving parts, and it is not implemented in the test suite -- just in the client, which we don't use for these tests.

One of the goals I am trying to achieve here is actually to be able to test the various connection methods at the lldb-server level, but for that I need to untangle the connection code from the rest of the test suite setup. And ideally I would only support one method (the simplest one) for the remote connections and have mark other tests @skipIfRemote -- the reason for that is that we'd need different code to (e.g.) read the server-selected port from a remote machine than we would for the local one, so this would be more of a test of the test suite than the server itself.

In D117559#3254148, @omjavaid wrote:

This doesnt interfere with LLDB tests for SVE. Rather I have not used it in a while for SVE tests I ahve using setup similar to to one David has explained above.

If you're using the setup that David mentioned, then this would break that.

I am going to try to make a patch to use reverse connect for these tests instead.

@labath Do you know if android adb based tests are being run anywhere? Are we still maintaining this support and does it work?

I would guess "no", but I don't know, really. I created this patch to find that out myself. :)

[labath]

Remove just the forward-connect logic instead.

[labath]

Sorry about the delay. Here's the version which switches to reverse connect everywhere. Please try it out.

[DavidSpickett]

FYI I am testing this locally, didn't work straight away but I think this might be networking issues on my part. Taking some time to check that.

[DavidSpickett]

I was able to use the commands I showed before successfully but only after making these changes:

--- a/lldb/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py
+++ b/lldb/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py
@@ -231,14 +231,15 @@ class GdbRemoteTestCaseBase(Base):
         return target.GetByteOrder()

     def launch_debug_monitor(self, attach_pid=None, logfile=None):
-        family, type, proto, _, addr = socket.getaddrinfo("localhost", 0, proto=socket.IPPROTO_TCP)[0]
+        info = socket.getaddrinfo("0.0.0.0", 0, proto=socket.IPPROTO_TCP)
+        family, type, proto, _, addr = info[0]
         sock = socket.socket(family, type, proto)
         sock.settimeout(self.DEFAULT_TIMEOUT)

         sock.bind(addr)
         sock.listen(1)
         addr = sock.getsockname()
-        self.connect_address = "[{}]:{}".format(*addr)
+        self.connect_address = "[{}]:{}".format(socket.getfqdn(), addr[1])

This is a hack obviously but it fixes the issues my particular setup has:

• By asking for "localhost" we get the IPV6 interface first and the QEMU VM doesn't have IPV6 to the host. (I'm sure it could with some extra setup)
• "0.0.0.0" fixes that issue since it's an IPV4 special address. (and means the port can be connected to externally?)
• Then we were telling lldb-server in the VM to connect to a local port, not to the port on the host. getfqdn fixes that.

So I end up with the host side listening to 0.0.0.0:<port> and lldb-server in the VM connecting to <host's hostname>:<port> and that works.

If we want this scenario to work (and it's not a dodgy network setup on my part) perhaps we could take a hint from how we're connected to the initial platform?

Connecting to remote platform 'remote-linux' at 'connect://<VM IPv4 address>:54321'

So here we could assume that IPv4 is ok and since the hostname isn't any sort of localhost we need to tell the lldb-server to connect to the hostname of the machine running the tests.
(though that assumes you can in fact connect to that from the VM, with what I have, you can)

[labath]

(Thanks for trying this out, I'm still thinking about the best way to move this forward.)

lldb/packages/Python/lldbsuite/test/lldbtest.py

def __init__(self, trace_on):
         self._proc = None
         self._trace_on = trace_on
         self._delayafterterminate = 0.1
 
     @property
     def pid(self):
         return self._proc.pid
 
-    def launch(self, executable, args, extra_env):
+    def launch(self, executable, args, extra_env, stderr=None):
         env=None
         if extra_env:
             env = dict(os.environ)
             env.update([kv.split("=", 1) for kv in extra_env])
 
         self._proc = Popen(
             [executable] + args,
-            stdout=open(
-                os.devnull) if not self._trace_on else None,
+            stdout=open(os.devnull) if not self._trace_on else None,
             stdin=PIPE,
+            stderr=stderr,
             preexec_fn=lldbplatformutil.enable_attach,
             env=env)
 
     def terminate(self):
         if self._proc.poll() is None:
             # Terminate _proc like it does the pexpect
             signals_to_try = [
                 sig for sig in [
def terminate(self):
             time.sleep(self._delayafterterminate)
 
     def poll(self):
         return self._proc.poll()
 
     def wait(self, timeout=None):
         return self._proc.wait(timeout)
 
+    def communicate(self, timeout=None):
+        return self._proc.communicate(timeout=timeout)
+
 
 class _RemoteProcess(_BaseProcess):
 
     def __init__(self, install_remote):
         self._pid = None
         self._install_remote = install_remote
 
     @property
class Base(unittest2.TestCase):
 
     def cleanupSubprocesses(self):
         # Terminate subprocesses in reverse order from how they were created.
         for p in reversed(self.subprocesses):
             p.terminate()
             del p
         del self.subprocesses[:]
 
-    def spawnSubprocess(self, executable, args=[], extra_env=None, install_remote=True):
+    def spawnSubprocess(self, executable, args=[], extra_env=None,
+            install_remote=True, **kwargs):
         """ Creates a subprocess.Popen object with the specified executable and arguments,
             saves it in self.subprocesses, and returns the object.
         """
         proc = _RemoteProcess(
             install_remote) if lldb.remote_platform else _LocalProcess(self.TraceOn())
-        proc.launch(executable, args, extra_env=extra_env)
+        proc.launch(executable, args, extra_env=extra_env, **kwargs)
         self.subprocesses.append(proc)
         return proc
 
     def HideStdout(self):
         """Hide output to stdout from the user.
 
         During test execution, there might be cases where we don't want to show the
         standard output to the user.  For example,

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

 import time
 from lldbsuite.test import configuration
 from lldbsuite.test.lldbtest import *
 from lldbsuite.support import seven
 from lldbgdbserverutils import *
 import logging
 
 
-class _ConnectionRefused(IOError):
-    pass
-
-
 class GdbRemoteTestCaseFactory(type):
 
     def __new__(cls, name, bases, attrs):
         newattrs = {}
         for attrname, attrvalue in attrs.items():
             if not attrname.startswith("test"):
                 newattrs[attrname] = attrvalue
                 continue
def setUp(self):
             self._verbose_log_handler = logging.FileHandler(
                 self.getLogBasenameForCurrentTest() + "-host.log")
             self._verbose_log_handler.setFormatter(self._log_formatter)
             self._verbose_log_handler.setLevel(logging.DEBUG)
             self.logger.addHandler(self._verbose_log_handler)
 
         self.test_sequence = GdbRemoteTestSequence(self.logger)
         self.set_inferior_startup_launch()
-        self.port = self.get_next_port()
         self.stub_sends_two_stop_notifications_on_kill = False
-        if configuration.lldb_platform_url:
-            if configuration.lldb_platform_url.startswith('unix-'):
-                url_pattern = '(.+)://\[?(.+?)\]?/.*'
-            else:
-                url_pattern = '(.+)://(.+):\d+'
-            scheme, host = re.match(
-                url_pattern, configuration.lldb_platform_url).groups()
-            if configuration.lldb_platform_name == 'remote-android' and host != 'localhost':
-                self.stub_device = host
-                self.stub_hostname = 'localhost'
-            else:
-                self.stub_device = None
-                self.stub_hostname = host
-        else:
-            self.stub_hostname = "localhost"
 
         debug_server = self.getDebugServer()
         if debug_server == "debugserver":
             self._init_debugserver_test()
         else:
             self._init_llgs_test()
 
     def tearDown(self):
def setUpServerLogging(self, is_llgs):
         if is_llgs:
             self.debug_monitor_extra_args.append("--log-file=" + log_file)
             self.debug_monitor_extra_args.append(
                 "--log-channels={}".format(":".join(lldbtest_config.channels)))
         else:
             self.debug_monitor_extra_args = [
                 "--log-file=" + log_file, "--log-flags=0x800000"]
 
-    def get_next_port(self):
-        return 12000 + random.randint(0, 3999)
-
     def reset_test_sequence(self):
         self.test_sequence = GdbRemoteTestSequence(self.logger)
 
 
     def _init_llgs_test(self):
-        reverse_connect = True
         if lldb.remote_platform:
-            # Reverse connections may be tricky due to firewalls/NATs.
-            reverse_connect = False
-
             # FIXME: This is extremely linux-oriented
 
             # Grab the ppid from /proc/[shell pid]/stat
             err, retcode, shell_stat = self.run_platform_command(
                 "cat /proc/$$/stat")
             self.assertTrue(
                 err.Success() and retcode == 0,
                 "Failed to read file /proc/$$/stat: %s, retcode: %d" %
def _init_llgs_test(self):
             # Remove if it's there.
             self.debug_monitor_exe = re.sub(r' \(deleted\)$', '', exe)
         else:
             self.debug_monitor_exe = get_lldb_server_exe()
 
         self.debug_monitor_extra_args = ["gdbserver"]
         self.setUpServerLogging(is_llgs=True)
 
-        self.reverse_connect = reverse_connect
-
     def _init_debugserver_test(self):
         self.debug_monitor_exe = get_debugserver_exe()
         self.setUpServerLogging(is_llgs=False)
-        self.reverse_connect = True
 
         # 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 forward_adb_port(self, source, target, direction, device):
-        adb = ['adb'] + (['-s', device] if device else []) + [direction]
-
-        def remove_port_forward():
-            subprocess.call(adb + ["--remove", "tcp:%d" % source])
-
-        subprocess.call(adb + ["tcp:%d" % source, "tcp:%d" % target])
-        self.addTearDownHook(remove_port_forward)
-
-    def _verify_socket(self, sock):
-        # Normally, when the remote stub is not ready, we will get ECONNREFUSED during the
-        # connect() attempt. However, due to the way how ADB forwarding works, on android targets
-        # the connect() will always be successful, but the connection will be immediately dropped
-        # if ADB could not connect on the remote side. This function tries to detect this
-        # situation, and report it as "connection refused" so that the upper layers attempt the
-        # connection again.
-        triple = self.dbg.GetSelectedPlatform().GetTriple()
-        if not re.match(".*-.*-.*-android", triple):
-            return  # Not android.
-        can_read, _, _ = select.select([sock], [], [], 0.1)
-        if sock not in can_read:
-            return  # Data is not available, but the connection is alive.
-        if len(sock.recv(1, socket.MSG_PEEK)) == 0:
-            raise _ConnectionRefused()  # Got EOF, connection dropped.
-
-    def create_socket(self):
-        try:
-            sock = socket.socket(family=socket.AF_INET)
-        except OSError as e:
-            if e.errno != errno.EAFNOSUPPORT:
-                raise
-            sock = socket.socket(family=socket.AF_INET6)
-
-        logger = self.logger
-
-        triple = self.dbg.GetSelectedPlatform().GetTriple()
-        if re.match(".*-.*-.*-android", triple):
-            self.forward_adb_port(
-                self.port,
-                self.port,
-                "forward",
-                self.stub_device)
-
-        logger.info(
-            "Connecting to debug monitor on %s:%d",
-            self.stub_hostname,
-            self.port)
-        connect_info = (self.stub_hostname, self.port)
-        try:
-            sock.connect(connect_info)
-        except socket.error as serr:
-            if serr.errno == errno.ECONNREFUSED:
-                raise _ConnectionRefused()
-            raise serr
-
-        def shutdown_socket():
-            if sock:
-                try:
-                    # send the kill packet so lldb-server shuts down gracefully
-                    sock.sendall(GdbRemoteTestCaseBase._GDBREMOTE_KILL_PACKET)
-                except:
-                    logger.warning(
-                        "failed to send kill packet to debug monitor: {}; ignoring".format(
-                            sys.exc_info()[0]))
-
-                try:
-                    sock.close()
-                except:
-                    logger.warning(
-                        "failed to close socket to debug monitor: {}; ignoring".format(
-                            sys.exc_info()[0]))
-
-        self.addTearDownHook(shutdown_socket)
-
-        self._verify_socket(sock)
-
-        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_args(self, attach_pid=None):
         commandline_args = self.debug_monitor_extra_args
         if attach_pid:
             commandline_args += ["--attach=%d" % attach_pid]
-        if self.reverse_connect:
-            commandline_args += ["--reverse-connect", self.connect_address]
-        else:
-            if lldb.remote_platform:
-                commandline_args += ["*:{}".format(self.port)]
-            else:
-                commandline_args += ["localhost:{}".format(self.port)]
-
         return commandline_args
 
     def get_target_byte_order(self):
         inferior_exe_path = self.getBuildArtifact("a.out")
         target = self.dbg.CreateTarget(inferior_exe_path)
         return target.GetByteOrder()
 
     def launch_debug_monitor(self, attach_pid=None, logfile=None):
-        if self.reverse_connect:
-            family, type, proto, _, addr = socket.getaddrinfo("localhost", 0, proto=socket.IPPROTO_TCP)[0]
-            sock = socket.socket(family, type, proto)
-            sock.settimeout(self.DEFAULT_TIMEOUT)
 
-            sock.bind(addr)
-            sock.listen(1)
-            addr = sock.getsockname()
-            self.connect_address = "[{}]:{}".format(*addr)
 
-
         # Create the command line.
         commandline_args = self.get_debug_monitor_command_line_args(
             attach_pid=attach_pid)
 
         # Start the server.
         server = self.spawnSubprocess(
             self.debug_monitor_exe,
             commandline_args,
             install_remote=False)
         self.assertIsNotNone(server)
 
-        if self.reverse_connect:
-            self.sock = sock.accept()[0]
-            self.sock.settimeout(self.DEFAULT_TIMEOUT)
 
         return server
 
     def connect_to_debug_monitor(self, attach_pid=None):
-        if self.reverse_connect:
-            # Create the stub.
-            server = self.launch_debug_monitor(attach_pid=attach_pid)
-            self.assertIsNotNone(server)
 
-            # Schedule debug monitor to be shut down during teardown.
-            logger = self.logger
 
-            self._server = Server(self.sock, server)
-            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)
-
-            # Schedule debug monitor to be shut down during teardown.
-            logger = self.logger
-
-            connect_attemps = 0
-            MAX_CONNECT_ATTEMPTS = 10
-
-            while connect_attemps < MAX_CONNECT_ATTEMPTS:
-                # Create a socket to talk to the server
-                try:
-                    logger.info("Connect attempt %d", connect_attemps + 1)
-                    self.sock = self.create_socket()
-                    self._server = Server(self.sock, server)
-                    return server
-                except _ConnectionRefused as serr:
-                    # Ignore, and try again.
-                    pass
-                time.sleep(0.5)
-                connect_attemps += 1
-
-            # We should close the server here to be safe.
-            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):
         # 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.

lldb/test/API/tools/lldb-server/TestGdbRemoteCompletion.py

 import tempfile
 import gdbremote_testcase
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 from lldbgdbserverutils import *
 
+@skipIfRemote
 class GdbRemoteCompletionTestCase(gdbremote_testcase.GdbRemoteTestCaseBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def init_lldb_server(self):
+        family, type, proto, _, addr = socket.getaddrinfo(
+            "localhost", 0, proto=socket.IPPROTO_TCP)[0]
+
         self.debug_monitor_exe = get_lldb_server_exe()
         if not self.debug_monitor_exe:
             self.skipTest("lldb-server exe not found")
         port_file = tempfile.NamedTemporaryFile().name
         commandline_args = [
             "platform",
             "--listen",
-            "*:0",
+            "[{}]:{}".format(*addr),
             "--socket-file",
             port_file
         ]
         server = self.spawnSubprocess(
             get_lldb_server_exe(),
             commandline_args,
             install_remote=False)
         self.assertIsNotNone(server)
-        self.stub_hostname = "localhost"
-        self.port = int(lldbutil.wait_for_file_on_target(self, port_file))
-        self.sock = self.create_socket()
+        port = int(lldbutil.wait_for_file_on_target(self, port_file))
+
+        self.sock = socket.socket(family, type, proto)
+        self.sock.settimeout(self.DEFAULT_TIMEOUT)
+        addr = (addr[0], port)
+        self.sock.connect(addr)
         self._server = Server(self.sock, server)
 
         self.do_handshake()
 
     def generate_hex_path(self, target):
         return str(os.path.join(self.getBuildDir(), target)).encode().hex()
 
     @add_test_categories(["llgs"])

lldb/test/API/tools/lldb-server/TestPtyServer.py

 import gdbremote_testcase
 import lldbgdbserverutils
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbgdbserverutils import *
 
 import xml.etree.ElementTree as ET
 
 
 @skipIfWindows
+@skipIfRemote
 class PtyServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         super().setUp()
         import pty
         import tty
         primary, secondary = pty.openpty()
         tty.setraw(primary)
         self._primary = io.FileIO(primary, 'r+b')
         self._secondary = io.FileIO(secondary, 'r+b')
 
-    def get_debug_monitor_command_line_args(self, attach_pid=None):
-        commandline_args = self.debug_monitor_extra_args
-        if attach_pid:
-            commandline_args += ["--attach=%d" % attach_pid]
+    def connect_to_debug_monitor(self, attach_pid=None):
+        self.assertIsNone(attach_pid)
 
+        # Create the command line.
         libc = ctypes.CDLL(None)
         libc.ptsname.argtypes = (ctypes.c_int,)
         libc.ptsname.restype = ctypes.c_char_p
         pty_path = libc.ptsname(self._primary.fileno()).decode()
-        commandline_args += ["serial://%s" % (pty_path,)]
-        return commandline_args
+        commandline_args = self.debug_monitor_extra_args + ["serial://%s" % (pty_path,)]
 
-    def connect_to_debug_monitor(self, attach_pid=None):
-        self.reverse_connect = False
-        server = self.launch_debug_monitor(attach_pid=attach_pid)
+        # Start the server.
+        server = self.spawnSubprocess(
+            self.debug_monitor_exe,
+            commandline_args,
+            install_remote=False)
         self.assertIsNotNone(server)
 
         # TODO: make it into proper abstraction
         class FakeSocket:
             def __init__(self, fd):
                 self.fd = fd
 
             def sendall(self, frame):

lldb/test/API/tools/lldb-server/commandline/TestGdbRemoteConnection.py

class Pipe(object):
         def close(self):
             os.close(self._fd)
 
 
 class TestGdbRemoteConnection(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipIfRemote  # reverse connect is not a supported use case for now
     def test_reverse_connect(self):
         # Reverse connect is the default connection method.
         self.connect_to_debug_monitor()
         # Verify we can do the handshake.  If that works, we'll call it good.
         self.do_handshake()
 
     @skipIfRemote
     def test_named_pipe(self):
         family, type, proto, _, addr = socket.getaddrinfo(
-            self.stub_hostname, 0, proto=socket.IPPROTO_TCP)[0]
+            "localhost", 0, proto=socket.IPPROTO_TCP)[0]
         self.sock = socket.socket(family, type, proto)
         self.sock.settimeout(self.DEFAULT_TIMEOUT)
 
         self.addTearDownHook(lambda: self.sock.close())
 
         pipe = Pipe(self.getBuildDir())
 
         self.addTearDownHook(lambda: pipe.close())
 
         args = self.debug_monitor_extra_args
-        if lldb.remote_platform:
-            args += ["*:0"]
-        else:
-            args += ["localhost:0"]
-
         args += ["--named-pipe", pipe.name]
 
         server = self.spawnSubprocess(
             self.debug_monitor_exe,
             args,
             install_remote=False)
 
         pipe.finish_connection(self.DEFAULT_TIMEOUT)
         port = pipe.read(10, self.DEFAULT_TIMEOUT)
         # Trim null byte, convert to int
         addr = (addr[0], int(port[:-1]))
         self.sock.connect(addr)
         self._server = Server(self.sock, server)
 
         # Verify we can do the handshake.  If that works, we'll call it good.
         self.do_handshake()
+
+    @skipIfRemote
+    def test_forward_connect(self):
+        family, type, proto, _, addr = socket.getaddrinfo(
+            "localhost", 0, proto=socket.IPPROTO_TCP)[0]
+        self.sock = socket.socket(family, type, proto)
+        self.sock.settimeout(self.DEFAULT_TIMEOUT)
+
+        self.addTearDownHook(lambda: self.sock.close())
+
+        for i in range(11):
+            if i == 10:
+                self.fail("Failed to connect after 10 attempts")
+            args = [] + self.debug_monitor_extra_args
+            port = random.randint(5000, 65000)
+            addr = (addr[0], port)
+            args += ["[{}]:{}".format(*addr)]
+
+            server = self.spawnSubprocess(self.debug_monitor_exe, args,
+                    stderr=subprocess.PIPE)
+
+            try:
+                (_, err) = server.communicate(timeout=10)
+                # The server (unexpectedly) exited. If that happened because the
+                # port was taken, try again.
+                self.assertIn(b"failed to connect", err)
+                continue
+            except subprocess.TimeoutExpired:
+                # Good. The server is waiting for us to connect.
+                break
+        self.assertIsNotNone(server)
+
+        self.sock.connect(addr)
+        self._server = Server(self.sock, server)
+
+        # Verify we can do the handshake.  If that works, we'll call it good.
+        self.do_handshake()