Allow multiple simultaneous connections to lldb-platform

[vharron]

Summary

lldb-platform's listener socket only had a backlog of one connection.
That means that if more than one client connected simultaneously, the
connection would be refused. The test suite can be run remotely with
dozens of threads connecting simultaneously. Raised this limit to 100
to effectively eliminate lost connections.

[tberghammer]

Looks good but please consider my inline comment

include/lldb/Host/Socket.h

64 ↗

(On Diff #22867)

I think you should leave the default value to be 1 unless you are sure nobody is depending on the original behavior.

[flackr]

include/lldb/Host/Socket.h

64 ↗

(On Diff #22867)

I agree, especially since the way this is used in ConnectionFileDescriptorPosix only accepts 1 connection.

[vharron]

the way this is used in ConnectionFileDescriptorPosix only accepts 1 connection.

I think we should keep it at 5. ConnectionFileDescriptorPosix will reject the connection if it is coming from the wrong port. That means a port scanner or some other random solar flare could theoretically block the good connection from getting in. I know I'm way out on a limb here but consider this: what is the downside? The system resources are irrelevant and if the listener is closed (like in ConnectionFileDescriptorPosix), the backlog is flushed.

That said, I really don't care.

[tberghammer]

If you are confident that it won't cause any regression then I am fine with increasing it to 5 but I have no idea how many different part of the code base use this class.

[flackr]

Fair enough. Since not every incoming connection will be accepted it makes sense to try to ensure we get the right connection if possible.

[clayborg]

Looks good.

lldb/trunk/include/lldb/Host/Socket.h

public:
     static const NativeSocket kInvalidSocketValue;
 
     Socket(NativeSocket socket, SocketProtocol protocol, bool should_close);
     ~Socket();
 
     // Initialize a Tcp Socket object in listening mode.  listen and accept are implemented
     // separately because the caller may wish to manipulate or query the socket after it is
     // initialized, but before entering a blocking accept.
-    static Error TcpListen(llvm::StringRef host_and_port, bool child_processes_inherit, Socket *&socket, Predicate<uint16_t>* predicate);
+    static Error TcpListen(
+        llvm::StringRef host_and_port,
+        bool child_processes_inherit,
+        Socket *&socket,
+        Predicate<uint16_t>* predicate,
+        int backlog = 5);
     static Error TcpConnect(llvm::StringRef host_and_port, bool child_processes_inherit, Socket *&socket);
     static Error UdpConnect(llvm::StringRef host_and_port, bool child_processes_inherit, Socket *&send_socket, Socket *&recv_socket);
     static Error UnixDomainConnect(llvm::StringRef host_and_port, bool child_processes_inherit, Socket *&socket);
     static Error UnixDomainAccept(llvm::StringRef host_and_port, bool child_processes_inherit, Socket *&socket);
 
     // Blocks on a listening socket until a connection is received.  This method assumes that
     // |this->m_socket| is a listening socket, created via either TcpListen() or via the native
     // constructor that takes a NativeSocket, which itself was created via a call to |listen()|

lldb/trunk/source/Host/common/Socket.cpp

Error Socket::TcpConnect(llvm::StringRef host_and_port, bool child_processes_inherit, Socket *&socket)
 
     // Keep our TCP packets coming without any delays.
     final_socket->SetOption(IPPROTO_TCP, TCP_NODELAY, 1);
     error.Clear();
     socket = final_socket.release();
     return error;
 }
 
-Error Socket::TcpListen(llvm::StringRef host_and_port, bool child_processes_inherit, Socket *&socket, Predicate<uint16_t>* predicate)
+Error Socket::TcpListen(
+    llvm::StringRef host_and_port,
+    bool child_processes_inherit,
+    Socket *&socket,
+    Predicate<uint16_t>* predicate,
+    int backlog)
 {
     std::unique_ptr<Socket> listen_socket;
     NativeSocket listen_sock = kInvalidSocketValue;
     Error error;
 
     const sa_family_t family = AF_INET;
     const int socktype = SOCK_STREAM;
     const int protocol = IPPROTO_TCP;
if (anyaddr.SetToAnyAddress (family, port))
         int err = ::bind (listen_sock, anyaddr, anyaddr.GetLength());
         if (err == -1)
         {
             // TODO: On Windows, use WSAGetLastError()
             error.SetErrorToErrno();
             return error;
         }
 
-        err = ::listen (listen_sock, 1);
+        err = ::listen (listen_sock, backlog);
         if (err == -1)
         {
             // TODO: On Windows, use WSAGetLastError()
             error.SetErrorToErrno();
             return error;
         }
 
         // We were asked to listen on port zero which means we

lldb/trunk/tools/lldb-server/lldb-platform.cpp

for (const auto &lldb_command : lldb_commands)
         if (output && output[0])
             puts(output);
     }
 
     std::unique_ptr<Socket> listening_socket_up;
     Socket *socket = nullptr;
     printf ("Listening for a connection from %s...\n", listen_host_port.c_str());
     const bool children_inherit_listen_socket = false;
-    error = Socket::TcpListen(listen_host_port.c_str(), children_inherit_listen_socket, socket, NULL);
+
+    // 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;
+    error = Socket::TcpListen(listen_host_port.c_str(), children_inherit_listen_socket, socket, NULL, backlog);
     if (error.Fail())
     {
         printf("error: %s\n", error.AsCString());
         exit(socket_error);
     }
     listening_socket_up.reset(socket);
 
     do {