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