code review 12476043: net: use F_DUPFD_CLOEXEC when duping fds

src/pkg/net/fd_unix.go

 // Copyright 2009 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 darwin freebsd linux netbsd openbsd
 
 package net
 
 import (
         "io"
         "os"
         "runtime"
         "sync"
+        "sync/atomic"
         "syscall"
         "time"
 )
 
 // Network file descriptor.
 type netFD struct {
         // locking/lifetime of sysfd
         sysmu  sync.Mutex
         sysref int
 
@@ skipping 374 matching lines @@
 
         if netfd, err = newFD(s, fd.family, fd.sotype, fd.net); err != nil {
                 closesocket(s)
                 return nil, err
         }
         lsa, _ := syscall.Getsockname(netfd.sysfd)
         netfd.setAddr(toAddr(lsa), toAddr(rsa))
         return netfd, nil
 }
 
-// dupCloseOnExec is a variable so it can be modified in fd_linux.go.
-var dupCloseOnExec = dupCloseOnExecUnix
-
-// dupCloseOnExecUnix is the traditional way to dup an fd and set
-// its O_CLOEXEC bit, using two system calls.
-func dupCloseOnExecUnix(fd int) (newfd int, err error) {
+// tryDupCloexec indicates whether F_DUPFD_CLOEXEC should be used.
+// If the kernel doesn't support it, this is set to 0.
+var tryDupCloexec = int32(1)
+
+func dupCloseOnExec(fd int) (newfd int, err error) {
+        if atomic.LoadInt32(&tryDupCloexec) == 1 {
+                r0, _, e1 := syscall.Syscall(syscall.SYS_FCNTL, uintptr(fd), syscall.F_DUPFD_CLOEXEC, 0)
+                switch e1 {
+                case 0:
+                        return int(r0), nil
+                case syscall.EINVAL:
+                        // Old kernel. Fall back to the portable way
+                        // from now on.
+                        atomic.StoreInt32(&tryDupCloexec, 0)
+                default:
+                        return -1, e1
+                }
+        }
+        return dupCloseOnExecOld(fd)
+}
+
+// dupCloseOnExecUnixOld is the traditional way to dup an fd and
+// set its O_CLOEXEC bit, using two system calls.
+func dupCloseOnExecOld(fd int) (newfd int, err error) {
         syscall.ForkLock.RLock()
         defer syscall.ForkLock.RUnlock()
-        ns, err := syscall.Dup(fd)
+        newfd, err = syscall.Dup(fd)
         if err != nil {
-                return
-        }
-        syscall.CloseOnExec(ns)
-        return ns, nil
+                return -1, err
+        }
+        syscall.CloseOnExec(newfd)
+        return
 }
 
 func (fd *netFD) dup() (f *os.File, err error) {
         ns, err := dupCloseOnExec(fd.sysfd)
         if err != nil {
                 syscall.ForkLock.RUnlock()
                 return nil, &OpError{"dup", fd.net, fd.laddr, err}
         }
 
         // We want blocking mode for the new fd, hence the double negative.
         // This also puts the old fd into blocking mode, meaning that
         // I/O will block the thread instead of letting us use the epoll server.
         // Everything will still work, just with more threads.
         if err = syscall.SetNonblock(ns, false); err != nil {
                 return nil, &OpError{"setnonblock", fd.net, fd.laddr, err}
         }
 
         return os.NewFile(uintptr(ns), fd.name()), nil
 }
 
 func closesocket(s int) error {
         return syscall.Close(s)
 }