1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
// 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.
package os
import (
"errors"
"runtime"
"syscall"
"time"
)
// StartProcess starts a new process with the program, arguments and attributes
// specified by name, argv and attr.
// If there is an error, it will be of type *PathError.
func StartProcess(name string, argv []string, attr *ProcAttr) (p *Process, err error) {
sysattr := &syscall.ProcAttr{
Dir: attr.Dir,
Env: attr.Env,
Sys: attr.Sys,
}
for _, f := range attr.Files {
sysattr.Files = append(sysattr.Files, f.Fd())
}
pid, h, e := syscall.StartProcess(name, argv, sysattr)
if e != nil {
return nil, &PathError{"fork/exec", name, e}
}
return newProcess(pid, h), nil
}
// Plan9Note implements the Signal interface on Plan 9.
type Plan9Note string
func (note Plan9Note) String() string {
return string(note)
}
func (p *Process) Signal(sig Signal) error {
if p.done {
return errors.New("os: process already finished")
}
f, e := OpenFile("/proc/"+itoa(p.Pid)+"/note", O_WRONLY, 0)
if e != nil {
return NewSyscallError("signal", e)
}
defer f.Close()
_, e = f.Write([]byte(sig.String()))
return e
}
// Kill causes the Process to exit immediately.
func (p *Process) Kill() error {
f, e := OpenFile("/proc/"+itoa(p.Pid)+"/ctl", O_WRONLY, 0)
if e != nil {
return NewSyscallError("kill", e)
}
defer f.Close()
_, e = f.Write([]byte("kill"))
return e
}
// Wait waits for the Process to exit or stop, and then returns a
// ProcessState describing its status and an error, if any.
func (p *Process) Wait() (ps *ProcessState, err error) {
var waitmsg syscall.Waitmsg
if p.Pid == -1 {
return nil, ErrInvalid
}
for true {
err = syscall.Await(&waitmsg)
if err != nil {
return nil, NewSyscallError("wait", err)
}
if waitmsg.Pid == p.Pid {
p.done = true
break
}
}
ps = &ProcessState{
pid: waitmsg.Pid,
status: &waitmsg,
}
return ps, nil
}
// Release releases any resources associated with the Process.
func (p *Process) Release() error {
// NOOP for Plan 9.
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 Plan 9.
return newProcess(pid, 0), nil
}
// ProcessState stores information about process as reported by Wait.
type ProcessState struct {
pid int // The process's id.
status *syscall.Waitmsg // System-dependent status info.
}
// Pid returns the process id of the exited process.
func (p *ProcessState) Pid() int {
return p.pid
}
// Exited returns whether the program has exited.
func (p *ProcessState) Exited() bool {
return p.status.Exited()
}
// Success reports whether the program exited successfully,
// such as with exit status 0 on Unix.
func (p *ProcessState) Success() bool {
return p.status.ExitStatus() == 0
}
// Sys returns system-dependent exit information about
// the process. Convert it to the appropriate underlying
// type, such as *syscall.Waitmsg on Plan 9, to access its contents.
func (p *ProcessState) Sys() interface{} {
return p.status
}
// SysUsage returns system-dependent resource usage information about
// the exited process. Convert it to the appropriate underlying
// type, such as *syscall.Waitmsg on Plan 9, to access its contents.
func (p *ProcessState) SysUsage() interface{} {
return p.status
}
// UserTime returns the user CPU time of the exited process and its children.
// It is always reported as 0 on Windows.
func (p *ProcessState) UserTime() time.Duration {
return time.Duration(p.status.Time[0]) * time.Millisecond
}
// SystemTime returns the system CPU time of the exited process and its children.
// It is always reported as 0 on Windows.
func (p *ProcessState) SystemTime() time.Duration {
return time.Duration(p.status.Time[1]) * time.Millisecond
}
func (p *ProcessState) String() string {
if p == nil {
return "<nil>"
}
return "exit status: " + p.status.Msg
}
|
