libgo/go/os/exec_unix.go

   1 // Copyright 2009 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 // +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris
   6
   7 package os
   8
   9 import (
  10         "errors"
  11         "runtime"
  12         "syscall"
  13         "time"
  14 )
  15
  16 func (p *Process) wait() (ps *ProcessState, err error) {
  17         if p.Pid == -1 {
  18                 return nil, syscall.EINVAL
  19         }
  20         var status syscall.WaitStatus
  21         var rusage syscall.Rusage
  22         pid1, e := syscall.Wait4(p.Pid, &status, 0, &rusage)
  23         if e != nil {
  24                 return nil, NewSyscallError("wait", e)
  25         }
  26         if pid1 != 0 {
  27                 p.setDone()
  28         }
  29         ps = &ProcessState{
  30                 pid:    pid1,
  31                 status: status,
  32                 rusage: &rusage,
  33         }
  34         return ps, nil
  35 }
  36
  37 func (p *Process) signal(sig Signal) error {
  38         if p.done() {
  39                 return errors.New("os: process already finished")
  40         }
  41         if p.Pid == -1 {
  42                 return errors.New("os: process already released")
  43         }
  44         s, ok := sig.(syscall.Signal)
  45         if !ok {
  46                 return errors.New("os: unsupported signal type")
  47         }
  48         if e := syscall.Kill(p.Pid, s); e != nil {
  49                 return e
  50         }
  51         return nil
  52 }
  53
  54 func (p *Process) release() error {
  55         // NOOP for unix.
  56         p.Pid = -1
  57         // no need for a finalizer anymore
  58         runtime.SetFinalizer(p, nil)
  59         return nil
  60 }
  61
  62 func findProcess(pid int) (p *Process, err error) {
  63         // NOOP for unix.
  64         return newProcess(pid, 0), nil
  65 }
  66
  67 func (p *ProcessState) userTime() time.Duration {
  68         return time.Duration(p.rusage.Utime.Nano()) * time.Nanosecond
  69 }
  70
  71 func (p *ProcessState) systemTime() time.Duration {
  72         return time.Duration(p.rusage.Stime.Nano()) * time.Nanosecond
  73 }