// 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. //go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris package os import ( "errors" "runtime" "syscall" "time" ) func (p *Process) wait() (ps *ProcessState, err error) { if p.Pid == -1 { return nil, syscall.EINVAL } // If we can block until Wait4 will succeed immediately, do so. ready, err := p.blockUntilWaitable() if err != nil { return nil, err } if ready { // Mark the process done now, before the call to Wait4, // so that Process.signal will not send a signal. p.setDone() // Acquire a write lock on sigMu to wait for any // active call to the signal method to complete. p.sigMu.Lock() p.sigMu.Unlock() } var ( status syscall.WaitStatus rusage syscall.Rusage pid1 int e error ) for { pid1, e = syscall.Wait4(p.Pid, &status, 0, &rusage) if e != syscall.EINTR { break } } if e != nil { return nil, NewSyscallError("wait", e) } if pid1 != 0 { p.setDone() } ps = &ProcessState{ pid: pid1, status: status, rusage: &rusage, } return ps, nil } func (p *Process) signal(sig Signal) error { if p.Pid == -1 { return errors.New("os: process already released") } if p.Pid == 0 { return errors.New("os: process not initialized") } p.sigMu.RLock() defer p.sigMu.RUnlock() if p.done() { return ErrProcessDone } s, ok := sig.(syscall.Signal) if !ok { return errors.New("os: unsupported signal type") } if e := syscall.Kill(p.Pid, s); e != nil { if e == syscall.ESRCH { return ErrProcessDone } return e } return nil } func (p *Process) release() error { // NOOP for unix. p.Pid = -1 // no need for a finalizer anymore runtime.SetFinalizer(p, nil) return nil } func findProcess(pid int) (p *Process, err error) { // NOOP for unix. return newProcess(pid, 0), nil } func (p *ProcessState) userTime() time.Duration { return time.Duration(p.rusage.Utime.Nano()) * time.Nanosecond } func (p *ProcessState) systemTime() time.Duration { return time.Duration(p.rusage.Stime.Nano()) * time.Nanosecond }