swift run: Speed up fd closes on macOS/Linux

Today, for everything that isn't the BSDs, we grab the
maximum number of open fds the process supports and then
loop through from 3 -> max, calling close(2) on everything.
Even for a low open fd count of 65k this will typically result
in 99+% of these close's being EBADF. At a 65k nofile RLIMIT
the sluggishness is not really felt, but on systems that may
have this in the millions it is extremely stark. `swift run`
on a hello world program can take minutes before the program
is actually ran.

There's a couple ways to work around this:

1. For Linux, on kernels 5.9 and up we have a handy friend named
close_range, which is similar to closefrom on the BSDs which we
already use.
2. If close_range doesn't exist we can read /proc/self/fd and
close everything manually above 3. It seems from some trial runs
there's really not all too many fds we hold open, so this is
around the same runtime as close_range. A similar avenue exists on
macOS in /dev/fd that we can use as well.

This change employs both of them for Linux, and only /dev/fd for macOS.
For Linux, we will try close_range first and if we get -1 (either for
ENOSYS as the syscall doesn't exist, or for any other error) we'll
fallback to the /proc method.

Below is the delta between two runs of `swift run` on a simple hello world
program. The shell I'm running these in has a nofile rlimit of 1 billion.
At 100 million it falls to about 20 seconds on my machine, and gets progressively
smaller until the two approaches aren't really any different at all.

With the patch:
```
Build of product 'closerange' complete! (0.17s)
Hello, world!

real	0m0.865s
user	0m0.702s
sys	0m0.110s
```

Without:
```
Build of product 'closerange' complete! (0.15s)
Hello, world!

real	2m43.203s
user	0m47.357s
sys	1m55.344s
```

Signed-off-by: Danny Canter <[email protected]>

Author: dcantah

Package.swift

@@ -515,6 +515,7 @@ let package = Package(
                 .product(name: "OrderedCollections", package: "swift-collections"),
                 "Basics",
                 "Build",
+                "CExecHelpers",
                 "CoreCommands",
                 "PackageGraph",
                 "PackageModelSyntax",
@@ -690,6 +691,13 @@ let package = Package(
             ]
         ),
 
+        // MARK: C helpers
+
+        .target(
+            name: "CExecHelpers",
+            dependencies: []
+        ),
+
         // MARK: Additional Test Dependencies
 
             .target(

Sources/CExecHelpers/exec_helpers.c

@@ -0,0 +1,90 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#include <dirent.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/resource.h>
+#include <limits.h>
+
+#include "include/exec_helpers.h"
+
+// glibc < 2.34 needs this. When running in a container it's possible the userland
+// doesn't have this defined in glibc, but the kernel supports the syscall. It's
+// very trivial to check via invoking it and checking for ENOSYS.
+#ifndef SYS_close_range
+#define SYS_close_range     436
+#endif
+
+static int highest_open_fd_dir(const char *fd_dir) {
+    DIR *dir = opendir(fd_dir);
+    if (dir == NULL) {
+        return -1;
+    }
+
+    int highest_fd = 0;
+    struct dirent *dir_entry = NULL;
+
+    while ((dir_entry = readdir(dir)) != NULL) {
+        if (dir_entry->d_name[0] < '0' || dir_entry->d_name[0] > '9') {
+            continue;
+        }
+
+        int fd = atoi(dir_entry->d_name);
+        if (fd > highest_fd) {
+            highest_fd = fd;
+        }
+     }
+
+    closedir(dir);
+    return highest_fd;
+}
+
+static int get_highest_open_fd() {
+    int highest_fd = -1;
+    #if defined(__APPLE__)
+    highest_fd = highest_open_fd_dir("/dev/fd");
+    #elif defined(__linux__)
+    highest_fd = highest_open_fd_dir("/proc/self/fd");
+    #endif
+
+    if (highest_fd != -1) {
+        return highest_fd;
+    }
+
+    struct rlimit rl;
+    if (getrlimit(RLIMIT_NOFILE, &rl) == 0) {
+        return rl.rlim_cur;
+    }
+
+    // Fallback to sysconf if our pal above didn't work.
+    return sysconf(_SC_OPEN_MAX);
+}
+
+void close_fds_from(unsigned int from) {
+    #if defined(__FreeBSD__) || defined(__OpenBSD__)
+    closefrom(from);
+    return;
+    #endif
+
+    #if defined(__linux__)
+    int ret = syscall(SYS_close_range, from, UINT_MAX, 0);
+    if (ret == 0) {
+        return;
+    }
+    #endif
+
+    int highest_fd = get_highest_open_fd();
+    for (int i=from; i<highest_fd; i++) {
+        close(i);
+    }
+}

Sources/CExecHelpers/include/exec_helpers.h

@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+void close_fds_from(unsigned int from);

Sources/CExecHelpers/include/module.modulemap

@@ -0,0 +1,4 @@
+module CExecHelpers {
+    header "exec_helpers.h"
+    export *
+}

Sources/Commands/SwiftRunCommand.swift

@@ -26,6 +26,10 @@ import enum TSCUtility.Diagnostics
 import Android
 #endif
 
+#if !os(Windows)
+import CExecHelpers
+#endif
+
 /// An enumeration of the errors that can be generated by the run tool.
 private enum RunError: Swift.Error {
     /// The package manifest has no executable product.
@@ -331,36 +335,30 @@ public struct SwiftRunCommand: AsyncSwiftCommand {
         #if !os(Windows)
         // Dispatch will disable almost all asynchronous signals on its worker threads, and this is called from `async`
         // context. To correctly `exec` a freshly built binary, we will need to:
-        // 1. reset the signal masks
+        // 1. Reset the signal masks
         for i in 1..<NSIG {
             signal(i, SIG_DFL)
         }
         var sig_set_all = sigset_t()
         sigfillset(&sig_set_all)
         sigprocmask(SIG_UNBLOCK, &sig_set_all, nil)
 
-        #if os(FreeBSD) || os(OpenBSD)
-        #if os(FreeBSD)
-        pthread_suspend_all_np()
-        #endif
-        closefrom(3)
-        #else
-        #if os(Android)
-        let number_fds = Int32(sysconf(_SC_OPEN_MAX))
-        #else
-        let number_fds = getdtablesize()
-        #endif /* os(Android) */
-        
-        // 2. close all file descriptors.
-        for i in 3..<number_fds {
-            close(i)
-        }
-        #endif /* os(FreeBSD) || os(OpenBSD) */
+        // 2. Close all file descriptors above stdio.
+        closeFdsAbove(3)
         #endif
 
         try TSCBasic.exec(path: path, args: args)
     }
 
+    #if !os(Windows)
+    private func closeFdsAbove(_ from: UInt32) {
+        #if os(FreeBSD)
+        pthread_suspend_all_np()
+        #endif
+        close_fds_from(from);
+    }
+    #endif
+
     public init() {}
 }