os/exec: create extra threads when starting a subprocess

TestExtraFiles seems to be flaky on GNU/Linux systems when using cgo
because creating a new thread will call malloc which can create a new
arena which can open a file to see how many processors there are.
Try to avoid the flake by creating several new threads at process
startup time.

For #25628

Change-Id: Ie781acdbba475d993c39782fe172cf7f29a05b24
Reviewed-on: https://go-review.googlesource.com/c/go/+/228099
Reviewed-by: Bryan C. Mills <bcmills@google.com>

diff --git a/src/os/exec/exec_linux_test.go b/src/os/exec/exec_linux_test.go
new file mode 100644 (file)
index 0000000..6f85020
--- /dev/null
+++ b/src/os/exec/exec_linux_test.go
@@ -0,0 +1,45 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build linux,cgo
+
+// On systems that use glibc, calling malloc can create a new arena,
+// and creating a new arena can read /sys/devices/system/cpu/online.
+// If we are using cgo, we will call malloc when creating a new thread.
+// That can break TestExtraFiles if we create a new thread that creates
+// a new arena and opens the /sys file while we are checking for open
+// file descriptors. Work around the problem by creating threads up front.
+// See issue 25628.
+
+package exec_test
+
+import (
+       "os"
+       "sync"
+       "syscall"
+       "time"
+)
+
+func init() {
+       if os.Getenv("GO_WANT_HELPER_PROCESS") != "1" {
+               return
+       }
+
+       // Start some threads. 10 is arbitrary but intended to be enough
+       // to ensure that the code won't have to create any threads itself.
+       // In particular this should be more than the number of threads
+       // the garbage collector might create.
+       const threads = 10
+
+       var wg sync.WaitGroup
+       wg.Add(threads)
+       ts := syscall.NsecToTimespec((100 * time.Microsecond).Nanoseconds())
+       for i := 0; i < threads; i++ {
+               go func() {
+                       defer wg.Done()
+                       syscall.Nanosleep(&ts, nil)
+               }()
+       }
+       wg.Wait()
+}