pkg:syscall: fix a bug in the shuffling of file descrip...

src/pkg/syscall/exec_linux.go

 // Copyright 2011 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
 
 package syscall
 
 import (
         "unsafe"
@@ skipping 23 matching lines @@
         // Declare all variables at top in case any
         // declarations require heap allocation (e.g., err1).
         var (
                 r1     uintptr
                 err1   Errno
                 nextfd int
                 i      int
         )
 
         // guard against side effects of shuffling fds below.
+        // Make sure that nextfd is beyond any currently open files so
+        // that we can't run the risk of overwriting any of them.
         fd := make([]int, len(attr.Files))
+        nextfd = len(attr.Files)
         for i, ufd := range attr.Files {
+                if nextfd < int(ufd) {
+                        nextfd = int(ufd)
+                }
                 fd[i] = int(ufd)
         }
+        nextfd++
 
         // About to call fork.
         // No more allocation or calls of non-assembly functions.
         r1, _, err1 = RawSyscall(SYS_FORK, 0, 0, 0)
         if err1 != 0 {
                 return 0, err1
         }
 
         if r1 != 0 {
                 // parent; return PID
@@ skipping 78 matching lines @@
         // Chdir
         if dir != nil {
                 _, _, err1 = RawSyscall(SYS_CHDIR, uintptr(unsafe.Pointer(dir)), 0, 0)
                 if err1 != 0 {
                         goto childerror
                 }
         }
 
         // Pass 1: look for fd[i] < i and move those up above len(fd)
         // so that pass 2 won't stomp on an fd it needs later.
-        nextfd = int(len(fd))
         if pipe < nextfd {
                 _, _, err1 = RawSyscall(SYS_DUP2, uintptr(pipe), uintptr(nextfd), 0)
                 if err1 != 0 {
                         goto childerror
                 }
                 RawSyscall(SYS_FCNTL, uintptr(nextfd), F_SETFD, FD_CLOEXEC)
                 pipe = nextfd
                 nextfd++
         }
         for i = 0; i < len(fd); i++ {
@@ skipping 86 matching lines @@
                 if err = Pipe(p); err != nil {
                         return
                 }
                 if _, err = fcntl(p[0], F_SETFD, FD_CLOEXEC); err != nil {
                         return
                 }
                 _, err = fcntl(p[1], F_SETFD, FD_CLOEXEC)
         }
         return
 }