code review 3816043: syscall: Plan 9 support for x86.

src/pkg/syscall/exec_plan9.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.
 
 // Fork, exec, wait, etc.
 
 package syscall
 
 import (
         "sync"
@@ skipping 53 matching lines @@
 // of NUL-terminated byte pointer.
 func StringArrayPtr(ss []string) []*byte {
         bb := make([]*byte, len(ss)+1)
         for i := 0; i < len(ss); i++ {
                 bb[i] = StringBytePtr(ss[i])
         }
         bb[len(ss)] = nil
         return bb
 }
 
-// Read a 16-bit numeric value from a 9P
-// protocol message b, returning the value
-// and the remaining slice of b.
+// gbit16 reads a 16-bit numeric value from a 9P protocol message strored in b,
+// returning the value and the remaining slice of b.
 func gbit16(b []byte) (uint16, []byte) {
         return uint16(b[0]) | uint16(b[1])<<8, b[2:]
 }
 
-// Read a string from a 9P protocol message b,
-// returning the value and the remaining slice of b.
+// gstring reads a string from a 9P protocol message strored in b,
+// returning the value as a Go string and the remaining slice of b.
 func gstring(b []byte) (string, []byte) {
         n, b := gbit16(b)
         return string(b[0:n]), b[n:]
 }
 
-// Return file names inside a directory·
-// already opened for reading dirfd.
+// readdirnames returns the names of files inside the directory represented by dirfd.
 func readdirnames(dirfd int) (names []string, err Error) {
         result := make([]string, 0, 100)
         var buf [STATMAX]byte
 
         for {
                 n, e := Read(dirfd, buf[:])
                 if e != nil {
                         return []string{}, e
                 }
                 if n == 0 {
@@ skipping 10 matching lines @@
 
                         name, _ := gstring(buf[i+41:])
                         result = append(result, name)
 
                         i += int(m)
                 }
         }
         return []string{}, nil
 }
 
-// Return a list of currently opened fds (excluding stdin, stdout, stderr)
-// by reading the special dup device #d.
-// ForkLock should be write locked before calling,
-// so that no new fds would be created while reading the fd list.
+// readdupdevice returns a list of currently opened fds (excluding stdin, stdout, stderr) from the dup device #d.
+// ForkLock should be write locked before calling, so that no new fds would be created while the fd list is being read.
 func readdupdevice() (fds []int, err Error) {
         dupdevfd, err := Open("#d", O_RDONLY)
 
         if err != nil {
                 return
         }
         defer Close(dupdevfd)
 
-        file_names, err := readdirnames(dupdevfd)
+        fileNames, err := readdirnames(dupdevfd)
         if err != nil {
                 return
         }
 
-        fds = make([]int, 0, len(file_names)>>1)
-        for _, fdstr := range file_names {
+        fds = make([]int, 0, len(fileNames)>>1)
+        for _, fdstr := range fileNames {
                 if l := len(fdstr); l > 2 && fdstr[l-3] == 'c' && fdstr[l-2] == 't' && fdstr[l-1] == 'l' {
                         continue
                 }
 
                 fd := int(atoi([]byte(fdstr)))
 
                 if fd == 0 || fd == 1 || fd == 2 || fd == dupdevfd {
                         continue
                 }
 
                 fds = append(fds, fd)
         }
 
         return fds[0:len(fds)], nil
 }
 
-var startup_fds []int
+var startupFds []int
 
 // Plan 9 does not allow clearing the OCEXEC flag
 // from the underlying channel backing an open file descriptor,
 // therefore we store a list of already opened file descriptors
-// inside startup_fds, and skip them when manually closing descriptors
-// not ment to be passed to a child exec.
+// inside startupFds and skip them when manually closing descriptors
+// not meant to be passed to a child exec.
 func init() {
-        startup_fds, _ = readdupdevice()
-}
-
-// Fork, dup fd onto 0..len(fd), and exec(argv0, argvv, envv) in child.
-// If a dup or exec fails, write the errstr int to pipe.
+        startupFds, _ = readdupdevice()
+}
+
+// forkAndExecInChild forks the process, calling dup onto 0..len(fd)
+// and finally invoking exec(argv0, argvv, envv) in the child.
+// If a dup or exec fails, it writes the error string to pipe.
 // (The pipe write end is close-on-exec so if exec succeeds, it will be closed.)
+//
 // In the child, this function must not acquire any locks, because
 // they might have been locked at the time of the fork.  This means
 // no rescheduling, no malloc calls, and no new stack segments.
 // The calls to RawSyscall are okay because they are assembly
 // functions that do not grow the stack.
-func forkAndExecInChild(argv0 *byte, argv []*byte, envv []envItem, dir *byte, attr *ProcAttr, fdclose []int, pipe int) (pid int, err Error) {
+func forkAndExecInChild(argv0 *byte, argv []*byte, envv []envItem, chroot, dir *byte, attr *ProcAttr, fdsToClose []int, pipe int) (pid int, err Error) {
         // Declare all variables at top in case any
         // declarations require heap allocation (e.g., errbuf).
         var (
                 r1       uintptr
                 nextfd   int
                 i        int
                 clearenv int
                 envfd    int
                 errbuf   [ERRMAX]byte
         )
@@ skipping 13 matching lines @@
                 if int(r1) == -1 {
                         return 0, NewError(errstr())
                 }
                 // parent; return PID
                 return int(r1), nil
         }
 
         // Fork succeeded, now in child.
 
         // Close fds we don't need.
-        for i = 0; i < len(fdclose); i++ {
-                r1, _, _ = RawSyscall(SYS_CLOSE, uintptr(fdclose[i]), 0, 0)
+        for i = 0; i < len(fdsToClose); i++ {
+                r1, _, _ = RawSyscall(SYS_CLOSE, uintptr(fdsToClose[i]), 0, 0)
                 if int(r1) == -1 {
                         goto childerror
                 }
         }
 
         if envv != nil {
                 // Write new environment variables.
                 for i = 0; i < len(envv); i++ {
                         r1, _, _ = RawSyscall(SYS_CREATE, uintptr(unsafe.Pointer(envv[i].name)), uintptr(O_WRONLY), uintptr(0666))
 
@@ skipping 89 matching lines @@
         for {
                 RawSyscall(SYS_EXITS, 0, 0, 0)
         }
 
         // Calling panic is not actually safe,
         // but the for loop above won't break
         // and this shuts up the compiler.
         panic("unreached")
 }
 
-func itoa(n int) string {
-        var buf [64]byte
-        j := len(buf)
-        for n > 0 {
-                j--
-                buf[j] = (byte)((n % 10) + '0')
-                n /= 10
-        }
-        return string(buf[j:])
-}
-
 func cexecPipe(p []int) Error {
         e := Pipe(p)
         if e != nil {
                 return e
         }
 
         fd, e := Open("#d/"+itoa(p[1]), O_CLOEXEC)
         if e != nil {
                 Close(p[0])
                 Close(p[1])
                 return e
         }
 
         Close(fd)
         return nil
 }
 
 type envItem struct {
         name   *byte
         value  *byte
         nvalue int
 }
 
 type ProcAttr struct {
-        Dir   string   // Current working directory.
-        Env   []string // Environment.
-        Files []int    // File descriptors.
+        Dir    string   // Current working directory.
+        Env    []string // Environment.
+        Files  []int    // File descriptors.
+        Chroot string   // Chroot.
 }
 
 var zeroAttributes ProcAttr
 
 
 func forkExec(argv0 string, argv []string, attr *ProcAttr) (pid int, err Error) {
         var (
                 p      [2]int
                 n      int
                 errbuf [ERRMAX]byte
                 wmsg   Waitmsg
         )
 
         if attr == nil {
                 attr = &zeroAttributes
         }
 
         p[0] = -1
         p[1] = -1
 
         // Convert args to C form.
         argv0p := StringBytePtr(argv[0])
         argvp := StringArrayPtr(argv)
-        var envv_parsed []envItem
-
+
+        var chroot *byte
+        if attr.Chroot != "" {
+                chroot = StringBytePtr(attr.Chroot)
+        }
         var dir *byte
         if attr.Dir != "" {
                 dir = StringBytePtr(attr.Dir)
         }
-
+        var envvParsed []envItem
         if attr.Env != nil {
-                envv_parsed = make([]envItem, 0, len(attr.Env))
+                envvParsed = make([]envItem, 0, len(attr.Env))
                 for _, v := range attr.Env {
                         i := 0
                         for i < len(v) && v[i] != '=' {
                                 i++
                         }
 
-                        envv_parsed = append(envv_parsed, envItem{StringBytePtr("/env/" + v[:i]), StringBytePtr(v[i+1:]), len(v) - i})
-                }
-        }
-
-        // Acquire the fork lock so that no other threads
-        // create new fds that are not yet close-on-exec
-        // before we fork.
+                        envvParsed = append(envvParsed, envItem{StringBytePtr("/env/" + v[:i]), StringBytePtr(v[i+1:]), len(v) - i})
+                }
+        }
+
+        // Acquire the fork lock to prevent other threads from creating new fds before we fork.
         ForkLock.Lock()
 
         // get a list of open fds, excluding stdin,stdout and stderr that need to be closed in the child.
         // no new fds can be created while we hold the ForkLock for writing.
-        fds_to_close, e := readdupdevice()
+        openFds, e := readdupdevice()
 
         if e != nil {
                 ForkLock.Unlock()
                 return 0, e
         }
 
+        fdsToClose := make([]int, 0, len(openFds))
         // exclude fds opened from startup from the list of fds to be closed.
-        for _, reserved_fd := range startup_fds {
-                for i := 0; i < len(fds_to_close); i++ {
-                        if reserved_fd == fds_to_close[i] {
-                                fds_to_close = append(fds_to_close[:i], fds_to_close[i+1:]...)
+        for _, fd := range openFds {
+                isReserved := false
+                for _, reservedFd := range startupFds {
+                        if fd == reservedFd {
+                                isReserved = true
                                 break
                         }
                 }
+
+                if !isReserved {
+                        fdsToClose = append(fdsToClose, fd)
+                }
         }
 
         // exclude fds requested by the caller from the list of fds to be closed.
-        for _, reserved_fd := range attr.Files {
-                for i := 0; i < len(fds_to_close); i++ {
-                        if reserved_fd == fds_to_close[i] {
-                                fds_to_close = append(fds_to_close[:i], fds_to_close[i+1:]...)
+        for _, fd := range openFds {
+                isReserved := false
+                for _, reservedFd := range attr.Files {
+                        if fd == reservedFd {
+                                isReserved = true
                                 break
                         }
+                }
+
+                if !isReserved {
+                        fdsToClose = append(fdsToClose, fd)
                 }
         }
 
         // Allocate child status pipe close on exec.····
         e = cexecPipe(p[:])
 
         if e != nil {
                 return 0, e
         }
-        fds_to_close = append(fds_to_close, p[0])
+        fdsToClose = append(fdsToClose, p[0])
 
         // Kick off child.
-        pid, err = forkAndExecInChild(argv0p, argvp, envv_parsed, dir, attr, fds_to_close, p[1])
+        pid, err = forkAndExecInChild(argv0p, argvp, envvParsed, chroot, dir, attr, fdsToClose, p[1])
 
         if err != nil {
                 if p[0] >= 0 {
                         Close(p[0])
                         Close(p[1])
                 }
                 ForkLock.Unlock()
                 return 0, err
         }
         ForkLock.Unlock()
@@ skipping 38 matching lines @@
                 if int(r1) == -1 {
                         return NewError(errstr())
                 }
 
                 for _, v := range envv {
                         i := 0
                         for i < len(v) && v[i] != '=' {
                                 i++
                         }
 
-                        r1, _, _ := RawSyscall(SYS_CREATE, uintptr(unsafe.Pointer(StringBytePtr("/env/"+v[:i]))),
-                                uintptr(O_WRONLY), uintptr(0666))
-                        if int(r1) == -1 {
-                                return NewError(errstr())
-                        }
-
-                        envfd := int(r1)
-
-                        r1, _, _ = RawSyscall6(SYS_PWRITE, uintptr(envfd), uintptr(unsafe.Pointer(StringBytePtr(v[i+1:]))),
-                                uintptr(len(v)-i), ^uintptr(0), ^uintptr(0), 0)
-                        if int(r1) == -1 || int(r1) != (len(v)-i) {
-                                return NewError(errstr())
-                        }
-
-                        r1, _, _ = RawSyscall(SYS_CLOSE, uintptr(envfd), 0, 0)
-                        if int(r1) == -1 {
-                                return NewError(errstr())
-                        }
+                        fd, e := Create("/env/"+v[:i], O_WRONLY, 0666)
+                        if e != nil {
+                                return e
+                        }
+
+                        _, e = Write(fd, []byte(v[i+1:]))
+                        if e != nil {
+                                Close(fd)
+                                return e
+                        }
+                        Close(fd)
                 }
         }
 
         _, _, e := Syscall(SYS_EXEC,
                 uintptr(unsafe.Pointer(StringBytePtr(argv0))),
                 uintptr(unsafe.Pointer(&StringArrayPtr(argv)[0])),
                 0)
 
         return NewError(e)
 }