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 5package os 6 7import ( 8 "errors" 9 "runtime" 10 "syscall" 11 "time" 12) 13 14// The only signal values guaranteed to be present on all systems 15// are Interrupt (send the process an interrupt) and Kill (force 16// the process to exit). 17var ( 18 Interrupt Signal = syscall.Note("interrupt") 19 Kill Signal = syscall.Note("kill") 20) 21 22func startProcess(name string, argv []string, attr *ProcAttr) (p *Process, err error) { 23 sysattr := &syscall.ProcAttr{ 24 Dir: attr.Dir, 25 Env: attr.Env, 26 Sys: attr.Sys, 27 } 28 29 for _, f := range attr.Files { 30 sysattr.Files = append(sysattr.Files, f.Fd()) 31 } 32 33 pid, h, e := syscall.StartProcess(name, argv, sysattr) 34 if e != nil { 35 return nil, &PathError{"fork/exec", name, e} 36 } 37 38 return newProcess(pid, h), nil 39} 40 41func (p *Process) writeProcFile(file string, data string) error { 42 f, e := OpenFile("/proc/"+itoa(p.Pid)+"/"+file, O_WRONLY, 0) 43 if e != nil { 44 return e 45 } 46 defer f.Close() 47 _, e = f.Write([]byte(data)) 48 return e 49} 50 51func (p *Process) signal(sig Signal) error { 52 if p.done() { 53 return errors.New("os: process already finished") 54 } 55 if e := p.writeProcFile("note", sig.String()); e != nil { 56 return NewSyscallError("signal", e) 57 } 58 return nil 59} 60 61func (p *Process) kill() error { 62 return p.signal(Kill) 63} 64 65func (p *Process) wait() (ps *ProcessState, err error) { 66 var waitmsg syscall.Waitmsg 67 68 if p.Pid == -1 { 69 return nil, ErrInvalid 70 } 71 err = syscall.WaitProcess(p.Pid, &waitmsg) 72 if err != nil { 73 return nil, NewSyscallError("wait", err) 74 } 75 76 p.setDone() 77 ps = &ProcessState{ 78 pid: waitmsg.Pid, 79 status: &waitmsg, 80 } 81 return ps, nil 82} 83 84func (p *Process) release() error { 85 // NOOP for Plan 9. 86 p.Pid = -1 87 // no need for a finalizer anymore 88 runtime.SetFinalizer(p, nil) 89 return nil 90} 91 92func findProcess(pid int) (p *Process, err error) { 93 // NOOP for Plan 9. 94 return newProcess(pid, 0), nil 95} 96 97// ProcessState stores information about a process, as reported by Wait. 98type ProcessState struct { 99 pid int // The process's id. 100 status *syscall.Waitmsg // System-dependent status info. 101} 102 103// Pid returns the process id of the exited process. 104func (p *ProcessState) Pid() int { 105 return p.pid 106} 107 108func (p *ProcessState) exited() bool { 109 return p.status.Exited() 110} 111 112func (p *ProcessState) success() bool { 113 return p.status.ExitStatus() == 0 114} 115 116func (p *ProcessState) sys() interface{} { 117 return p.status 118} 119 120func (p *ProcessState) sysUsage() interface{} { 121 return p.status 122} 123 124func (p *ProcessState) userTime() time.Duration { 125 return time.Duration(p.status.Time[0]) * time.Millisecond 126} 127 128func (p *ProcessState) systemTime() time.Duration { 129 return time.Duration(p.status.Time[1]) * time.Millisecond 130} 131 132func (p *ProcessState) String() string { 133 if p == nil { 134 return "<nil>" 135 } 136 return "exit status: " + p.status.Msg 137} 138