150 lines
3.5 KiB
Go
150 lines
3.5 KiB
Go
// 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.
|
|
|
|
// +build darwin freebsd linux netbsd openbsd windows
|
|
|
|
package os
|
|
|
|
import (
|
|
"runtime"
|
|
"syscall"
|
|
)
|
|
|
|
type UnixSignal int32
|
|
|
|
func (sig UnixSignal) String() string {
|
|
s := runtime.Signame(int32(sig))
|
|
if len(s) > 0 {
|
|
return s
|
|
}
|
|
return "UnixSignal"
|
|
}
|
|
|
|
// StartProcess starts a new process with the program, arguments and attributes
|
|
// specified by name, argv and attr.
|
|
//
|
|
// StartProcess is a low-level interface. The os/exec package provides
|
|
// higher-level interfaces.
|
|
func StartProcess(name string, argv []string, attr *ProcAttr) (p *Process, err error) {
|
|
sysattr := &syscall.ProcAttr{
|
|
Dir: attr.Dir,
|
|
Env: attr.Env,
|
|
Sys: attr.Sys,
|
|
}
|
|
if sysattr.Env == nil {
|
|
sysattr.Env = Environ()
|
|
}
|
|
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
|
|
}
|
|
|
|
// Kill causes the Process to exit immediately.
|
|
func (p *Process) Kill() error {
|
|
return p.Signal(SIGKILL)
|
|
}
|
|
|
|
// Exec replaces the current process with an execution of the
|
|
// named binary, with arguments argv and environment envv.
|
|
// If successful, Exec never returns. If it fails, it returns an error.
|
|
//
|
|
// To run a child process, see StartProcess (for a low-level interface)
|
|
// or the os/exec package (for higher-level interfaces).
|
|
func Exec(name string, argv []string, envv []string) error {
|
|
if envv == nil {
|
|
envv = Environ()
|
|
}
|
|
e := syscall.Exec(name, argv, envv)
|
|
if e != nil {
|
|
return &PathError{"exec", name, e}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// TODO(rsc): Should os implement its own syscall.WaitStatus
|
|
// wrapper with the methods, or is exposing the underlying one enough?
|
|
//
|
|
// TODO(rsc): Certainly need to have Rusage struct,
|
|
// since syscall one might have different field types across
|
|
// different OS.
|
|
|
|
// Waitmsg stores the information about an exited process as reported by Wait.
|
|
type Waitmsg struct {
|
|
Pid int // The process's id.
|
|
syscall.WaitStatus // System-dependent status info.
|
|
Rusage *syscall.Rusage // System-dependent resource usage info.
|
|
}
|
|
|
|
// Wait waits for process pid to exit or stop, and then returns a
|
|
// Waitmsg describing its status and an error, if any. The options
|
|
// (WNOHANG etc.) affect the behavior of the Wait call.
|
|
// Wait is equivalent to calling FindProcess and then Wait
|
|
// and Release on the result.
|
|
func Wait(pid int, options int) (w *Waitmsg, err error) {
|
|
p, e := FindProcess(pid)
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
defer p.Release()
|
|
return p.Wait(options)
|
|
}
|
|
|
|
// Convert i to decimal string.
|
|
func itod(i int) string {
|
|
if i == 0 {
|
|
return "0"
|
|
}
|
|
|
|
u := uint64(i)
|
|
if i < 0 {
|
|
u = -u
|
|
}
|
|
|
|
// Assemble decimal in reverse order.
|
|
var b [32]byte
|
|
bp := len(b)
|
|
for ; u > 0; u /= 10 {
|
|
bp--
|
|
b[bp] = byte(u%10) + '0'
|
|
}
|
|
|
|
if i < 0 {
|
|
bp--
|
|
b[bp] = '-'
|
|
}
|
|
|
|
return string(b[bp:])
|
|
}
|
|
|
|
func (w *Waitmsg) String() string {
|
|
if w == nil {
|
|
return "<nil>"
|
|
}
|
|
// TODO(austin) Use signal names when possible?
|
|
res := ""
|
|
switch {
|
|
case w.Exited():
|
|
res = "exit status " + itod(w.ExitStatus())
|
|
case w.Signaled():
|
|
res = "signal " + itod(w.Signal())
|
|
case w.Stopped():
|
|
res = "stop signal " + itod(w.StopSignal())
|
|
if w.StopSignal() == syscall.SIGTRAP && w.TrapCause() != 0 {
|
|
res += " (trap " + itod(w.TrapCause()) + ")"
|
|
}
|
|
case w.Continued():
|
|
res = "continued"
|
|
}
|
|
if w.CoreDump() {
|
|
res += " (core dumped)"
|
|
}
|
|
return res
|
|
}
|