Introduce optional 'bool shared' parameter to ServerSocket.bind() ...

dart/runtime/bin/eventhandler_linux.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/globals.h"
 #if defined(TARGET_OS_LINUX)
 
 #include "bin/eventhandler.h"
+#include "bin/eventhandler_linux.h"
 
 #include <errno.h>  // NOLINT
 #include <pthread.h>  // NOLINT
 #include <stdio.h>  // NOLINT
 #include <string.h>  // NOLINT
 #include <sys/epoll.h>  // NOLINT
 #include <sys/stat.h>  // NOLINT
 #include <sys/timerfd.h>  // NOLINT
 #include <unistd.h>  // NOLINT
 #include <fcntl.h>  // NOLINT
 
 #include "bin/dartutils.h"
 #include "bin/fdutils.h"
 #include "bin/log.h"
+#include "bin/lockers.h"
 #include "bin/socket.h"
 #include "bin/thread.h"
 #include "platform/utils.h"
 
 
 namespace dart {
 namespace bin {
 
 static const int kInterruptMessageSize = sizeof(InterruptMessage);
 static const int kTimerId = -1;
@@ skipping 170 matching lines @@
         ASSERT(!sd->IsListeningSocket());
         // Close the socket for reading.
         VOID_NO_RETRY_EXPECTED(shutdown(sd->fd(), SHUT_RD));
       } else if (IS_COMMAND(msg[i].data, kShutdownWriteCommand)) {
         ASSERT(!sd->IsListeningSocket());
         // Close the socket for writing.
         VOID_NO_RETRY_EXPECTED(shutdown(sd->fd(), SHUT_WR));
       } else if (IS_COMMAND(msg[i].data, kCloseCommand)) {
         // Close the socket and free system resources and move on to next
         // message.
-        if (sd->RemovePort(msg[i].dart_port)) {
+        bool no_more_listeners = sd->RemovePort(msg[i].dart_port);
+        if (no_more_listeners) {
           RemoveFromEpollInstance(epoll_fd_, sd);
+        }
+
+        if (sd->IsListeningSocket()) {
           intptr_t fd = sd->fd();
-          sd->Close();
-          socket_map_.Remove(GetHashmapKeyFromFd(fd), GetHashmapHashFromFd(fd));
-          delete sd;
+          // We only close the socket file descriptor from the operating
+          // system if there are no other dart socket objects which
+          // are listening on the same (address, port) combination.
+          {
+            MutexLocker ml(globalTcpListeningSocketRegistry.mutex());
+            if (globalTcpListeningSocketRegistry.CloseSafe(sd->fd())) {
+              ASSERT(no_more_listeners);
+              socket_map_.Remove(
+                  GetHashmapKeyFromFd(fd), GetHashmapHashFromFd(fd));
+              sd->Close();
+              delete sd;
+            }
+          }
+        } else {
+          if (no_more_listeners) {
+            intptr_t fd = sd->fd();
+            sd->Close();

[Søren Gjesse, 2015/01/29 09:05:51]

Move sd->Close() down below the removal from the map (like above).

[wibling, 2015/01/29 09:42:01]

Since it was closed before removal before shouldn't it be the above sd-Close()
that is moved before the map removal? Or was that a bug in the previous code?

[Søren Gjesse, 2015/01/29 10:12:55]

As far as I can see this could be a potential bug in the original code. You
close the fd, and then you might create a new one getting the same fd before it
is removed from the map. However as the eventhandler is single threaded it might
not be a problem...

[kustermann, 2015/01/29 11:14:04]

Yes, because only one thread owns/touches this, it's not an issue. But it's much
cleaner to move it after the removal of the hashmap.

+            socket_map_.Remove(
+                GetHashmapKeyFromFd(fd), GetHashmapHashFromFd(fd));
+            delete sd;
+          }
         }
         DartUtils::PostInt32(msg[i].dart_port, 1 << kDestroyedEvent);
       } else if (IS_COMMAND(msg[i].data, kReturnTokenCommand)) {
         int count = TOKEN_COUNT(msg[i].data);
         if (sd->ReturnToken(msg[i].dart_port, count)) {
           AddToEpollInstance(epoll_fd_, sd);
         }
       } else {
         ASSERT_NO_COMMAND(msg[i].data);
         // Setup events to wait for.
@@ skipping 131 matching lines @@
 
 uint32_t EventHandlerImplementation::GetHashmapHashFromFd(intptr_t fd) {
   // The hashmap does not support keys with value 0.
   return dart::Utils::WordHash(fd + 1);
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_LINUX)