github.com/c12o16h1/go/src@v0.0.0-20200114212001-5a151c0f00ed/syscall/exec_darwin.go (about) 1 // Copyright 2011 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 package syscall 6 7 import ( 8 "unsafe" 9 ) 10 11 type SysProcAttr struct { 12 Chroot string // Chroot. 13 Credential *Credential // Credential. 14 Ptrace bool // Enable tracing. 15 Setsid bool // Create session. 16 Setpgid bool // Set process group ID to Pgid, or, if Pgid == 0, to new pid. 17 Setctty bool // Set controlling terminal to fd Ctty 18 Noctty bool // Detach fd 0 from controlling terminal 19 Ctty int // Controlling TTY fd 20 Foreground bool // Place child's process group in foreground. (Implies Setpgid. Uses Ctty as fd of controlling TTY) 21 Pgid int // Child's process group ID if Setpgid. 22 } 23 24 // Implemented in runtime package. 25 func runtime_BeforeFork() 26 func runtime_AfterFork() 27 func runtime_AfterForkInChild() 28 29 // Fork, dup fd onto 0..len(fd), and exec(argv0, argvv, envv) in child. 30 // If a dup or exec fails, write the errno error to pipe. 31 // (Pipe is close-on-exec so if exec succeeds, it will be closed.) 32 // In the child, this function must not acquire any locks, because 33 // they might have been locked at the time of the fork. This means 34 // no rescheduling, no malloc calls, and no new stack segments. 35 // For the same reason compiler does not race instrument it. 36 // The calls to rawSyscall are okay because they are assembly 37 // functions that do not grow the stack. 38 //go:norace 39 func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr *ProcAttr, sys *SysProcAttr, pipe int) (pid int, err Errno) { 40 // Declare all variables at top in case any 41 // declarations require heap allocation (e.g., err1). 42 var ( 43 r1 uintptr 44 err1 Errno 45 nextfd int 46 i int 47 ) 48 49 // guard against side effects of shuffling fds below. 50 // Make sure that nextfd is beyond any currently open files so 51 // that we can't run the risk of overwriting any of them. 52 fd := make([]int, len(attr.Files)) 53 nextfd = len(attr.Files) 54 for i, ufd := range attr.Files { 55 if nextfd < int(ufd) { 56 nextfd = int(ufd) 57 } 58 fd[i] = int(ufd) 59 } 60 nextfd++ 61 62 // About to call fork. 63 // No more allocation or calls of non-assembly functions. 64 runtime_BeforeFork() 65 r1, _, err1 = rawSyscall(funcPC(libc_fork_trampoline), 0, 0, 0) 66 if err1 != 0 { 67 runtime_AfterFork() 68 return 0, err1 69 } 70 71 if r1 != 0 { 72 // parent; return PID 73 runtime_AfterFork() 74 return int(r1), 0 75 } 76 77 // Fork succeeded, now in child. 78 79 runtime_AfterForkInChild() 80 81 // Enable tracing if requested. 82 if sys.Ptrace { 83 if err := ptrace(PTRACE_TRACEME, 0, 0, 0); err != nil { 84 err1 = err.(Errno) 85 goto childerror 86 } 87 } 88 89 // Session ID 90 if sys.Setsid { 91 _, _, err1 = rawSyscall(funcPC(libc_setsid_trampoline), 0, 0, 0) 92 if err1 != 0 { 93 goto childerror 94 } 95 } 96 97 // Set process group 98 if sys.Setpgid || sys.Foreground { 99 // Place child in process group. 100 _, _, err1 = rawSyscall(funcPC(libc_setpgid_trampoline), 0, uintptr(sys.Pgid), 0) 101 if err1 != 0 { 102 goto childerror 103 } 104 } 105 106 if sys.Foreground { 107 pgrp := sys.Pgid 108 if pgrp == 0 { 109 r1, _, err1 = rawSyscall(funcPC(libc_getpid_trampoline), 0, 0, 0) 110 if err1 != 0 { 111 goto childerror 112 } 113 114 pgrp = int(r1) 115 } 116 117 // Place process group in foreground. 118 _, _, err1 = rawSyscall(funcPC(libc_ioctl_trampoline), uintptr(sys.Ctty), uintptr(TIOCSPGRP), uintptr(unsafe.Pointer(&pgrp))) 119 if err1 != 0 { 120 goto childerror 121 } 122 } 123 124 // Chroot 125 if chroot != nil { 126 _, _, err1 = rawSyscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(chroot)), 0, 0) 127 if err1 != 0 { 128 goto childerror 129 } 130 } 131 132 // User and groups 133 if cred := sys.Credential; cred != nil { 134 ngroups := uintptr(len(cred.Groups)) 135 groups := uintptr(0) 136 if ngroups > 0 { 137 groups = uintptr(unsafe.Pointer(&cred.Groups[0])) 138 } 139 if !cred.NoSetGroups { 140 _, _, err1 = rawSyscall(funcPC(libc_setgroups_trampoline), ngroups, groups, 0) 141 if err1 != 0 { 142 goto childerror 143 } 144 } 145 _, _, err1 = rawSyscall(funcPC(libc_setgid_trampoline), uintptr(cred.Gid), 0, 0) 146 if err1 != 0 { 147 goto childerror 148 } 149 _, _, err1 = rawSyscall(funcPC(libc_setuid_trampoline), uintptr(cred.Uid), 0, 0) 150 if err1 != 0 { 151 goto childerror 152 } 153 } 154 155 // Chdir 156 if dir != nil { 157 _, _, err1 = rawSyscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(dir)), 0, 0) 158 if err1 != 0 { 159 goto childerror 160 } 161 } 162 163 // Pass 1: look for fd[i] < i and move those up above len(fd) 164 // so that pass 2 won't stomp on an fd it needs later. 165 if pipe < nextfd { 166 _, _, err1 = rawSyscall(funcPC(libc_dup2_trampoline), uintptr(pipe), uintptr(nextfd), 0) 167 if err1 != 0 { 168 goto childerror 169 } 170 rawSyscall(funcPC(libc_fcntl_trampoline), uintptr(nextfd), F_SETFD, FD_CLOEXEC) 171 pipe = nextfd 172 nextfd++ 173 } 174 for i = 0; i < len(fd); i++ { 175 if fd[i] >= 0 && fd[i] < int(i) { 176 if nextfd == pipe { // don't stomp on pipe 177 nextfd++ 178 } 179 _, _, err1 = rawSyscall(funcPC(libc_dup2_trampoline), uintptr(fd[i]), uintptr(nextfd), 0) 180 if err1 != 0 { 181 goto childerror 182 } 183 rawSyscall(funcPC(libc_fcntl_trampoline), uintptr(nextfd), F_SETFD, FD_CLOEXEC) 184 fd[i] = nextfd 185 nextfd++ 186 } 187 } 188 189 // Pass 2: dup fd[i] down onto i. 190 for i = 0; i < len(fd); i++ { 191 if fd[i] == -1 { 192 rawSyscall(funcPC(libc_close_trampoline), uintptr(i), 0, 0) 193 continue 194 } 195 if fd[i] == int(i) { 196 // dup2(i, i) won't clear close-on-exec flag on Linux, 197 // probably not elsewhere either. 198 _, _, err1 = rawSyscall(funcPC(libc_fcntl_trampoline), uintptr(fd[i]), F_SETFD, 0) 199 if err1 != 0 { 200 goto childerror 201 } 202 continue 203 } 204 // The new fd is created NOT close-on-exec, 205 // which is exactly what we want. 206 _, _, err1 = rawSyscall(funcPC(libc_dup2_trampoline), uintptr(fd[i]), uintptr(i), 0) 207 if err1 != 0 { 208 goto childerror 209 } 210 } 211 212 // By convention, we don't close-on-exec the fds we are 213 // started with, so if len(fd) < 3, close 0, 1, 2 as needed. 214 // Programs that know they inherit fds >= 3 will need 215 // to set them close-on-exec. 216 for i = len(fd); i < 3; i++ { 217 rawSyscall(funcPC(libc_close_trampoline), uintptr(i), 0, 0) 218 } 219 220 // Detach fd 0 from tty 221 if sys.Noctty { 222 _, _, err1 = rawSyscall(funcPC(libc_ioctl_trampoline), 0, uintptr(TIOCNOTTY), 0) 223 if err1 != 0 { 224 goto childerror 225 } 226 } 227 228 // Set the controlling TTY to Ctty 229 if sys.Setctty { 230 _, _, err1 = rawSyscall(funcPC(libc_ioctl_trampoline), uintptr(sys.Ctty), uintptr(TIOCSCTTY), 0) 231 if err1 != 0 { 232 goto childerror 233 } 234 } 235 236 // Time to exec. 237 _, _, err1 = rawSyscall(funcPC(libc_execve_trampoline), 238 uintptr(unsafe.Pointer(argv0)), 239 uintptr(unsafe.Pointer(&argv[0])), 240 uintptr(unsafe.Pointer(&envv[0]))) 241 242 childerror: 243 // send error code on pipe 244 rawSyscall(funcPC(libc_write_trampoline), uintptr(pipe), uintptr(unsafe.Pointer(&err1)), unsafe.Sizeof(err1)) 245 for { 246 rawSyscall(funcPC(libc_exit_trampoline), 253, 0, 0) 247 } 248 }