2011-02-03 20:41:26 -07:00
|
|
|
// 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.
|
|
|
|
|
2011-12-17 08:29:18 -07:00
|
|
|
// +build darwin freebsd linux netbsd openbsd
|
build: add build comments to core packages
The go/build package already recognizes
system-specific file names like
mycode_darwin.go
mycode_darwin_386.go
mycode_386.s
However, it is also common to write files that
apply to multiple architectures, so a recent CL added
to go/build the ability to process comments
listing a set of conditions for building. For example:
// +build darwin freebsd openbsd/386
says that this file should be compiled only on
OS X, FreeBSD, or 32-bit x86 OpenBSD systems.
These conventions are not yet documented
(hence this long CL description).
This CL adds build comments to the multi-system
files in the core library, a step toward making it
possible to use go/build to build them.
With this change go/build can handle crypto/rand,
exec, net, path/filepath, os/user, and time.
os and syscall need additional adjustments.
R=golang-dev, r, gri, r, gustavo
CC=golang-dev
https://golang.org/cl/5011046
2011-09-15 14:48:57 -06:00
|
|
|
|
2011-02-03 20:41:26 -07:00
|
|
|
package os
|
|
|
|
|
|
|
|
import (
|
2011-11-01 19:49:08 -06:00
|
|
|
"errors"
|
2011-02-03 20:41:26 -07:00
|
|
|
"runtime"
|
|
|
|
"syscall"
|
2012-02-20 20:10:34 -07:00
|
|
|
"time"
|
2011-02-03 20:41:26 -07:00
|
|
|
)
|
|
|
|
|
2012-03-01 19:56:54 -07:00
|
|
|
func (p *Process) wait() (ps *ProcessState, err error) {
|
2011-02-03 20:41:26 -07:00
|
|
|
if p.Pid == -1 {
|
2012-02-16 16:04:29 -07:00
|
|
|
return nil, syscall.EINVAL
|
2011-02-03 20:41:26 -07:00
|
|
|
}
|
|
|
|
var status syscall.WaitStatus
|
2012-02-20 20:10:34 -07:00
|
|
|
var rusage syscall.Rusage
|
|
|
|
pid1, e := syscall.Wait4(p.Pid, &status, 0, &rusage)
|
2011-11-13 20:44:52 -07:00
|
|
|
if e != nil {
|
2011-02-03 20:41:26 -07:00
|
|
|
return nil, NewSyscallError("wait", e)
|
|
|
|
}
|
2012-02-19 21:36:08 -07:00
|
|
|
if pid1 != 0 {
|
2012-08-20 18:41:31 -06:00
|
|
|
p.setDone()
|
2011-07-11 16:47:42 -06:00
|
|
|
}
|
2012-02-20 20:10:34 -07:00
|
|
|
ps = &ProcessState{
|
|
|
|
pid: pid1,
|
2012-02-22 13:51:49 -07:00
|
|
|
status: status,
|
2012-02-20 20:10:34 -07:00
|
|
|
rusage: &rusage,
|
|
|
|
}
|
|
|
|
return ps, nil
|
2011-02-03 20:41:26 -07:00
|
|
|
}
|
|
|
|
|
2012-03-01 19:56:54 -07:00
|
|
|
func (p *Process) signal(sig Signal) error {
|
2012-08-20 18:41:31 -06:00
|
|
|
if p.done() {
|
2011-11-01 19:49:08 -06:00
|
|
|
return errors.New("os: process already finished")
|
2011-07-11 16:47:42 -06:00
|
|
|
}
|
os/signal: selective signal handling
Restore package os/signal, with new API:
Notify replaces Incoming, allowing clients
to ask for certain signals only. Also, signals
go to everyone who asks, not just one client.
This could plausibly move into package os now
that there are no magic side effects as a result
of the import.
Update runtime for new API: move common Unix
signal handling code into signal_unix.c.
(It's so easy to do this now that we don't have
to edit Makefiles!)
Tested on darwin,linux 386,amd64.
Fixes #1266.
R=r, dsymonds, bradfitz, iant, borman
CC=golang-dev
https://golang.org/cl/3749041
2012-02-13 11:52:37 -07:00
|
|
|
s, ok := sig.(syscall.Signal)
|
|
|
|
if !ok {
|
|
|
|
return errors.New("os: unsupported signal type")
|
|
|
|
}
|
|
|
|
if e := syscall.Kill(p.Pid, s); e != nil {
|
2011-11-13 20:44:52 -07:00
|
|
|
return e
|
2011-06-06 03:53:30 -06:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2012-02-29 23:36:35 -07:00
|
|
|
func (p *Process) release() error {
|
2011-02-03 20:41:26 -07:00
|
|
|
// NOOP for unix.
|
|
|
|
p.Pid = -1
|
|
|
|
// no need for a finalizer anymore
|
|
|
|
runtime.SetFinalizer(p, nil)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2012-01-16 22:51:54 -07:00
|
|
|
func findProcess(pid int) (p *Process, err error) {
|
2011-02-03 20:41:26 -07:00
|
|
|
// NOOP for unix.
|
|
|
|
return newProcess(pid, 0), nil
|
|
|
|
}
|
2012-02-20 20:10:34 -07:00
|
|
|
|
2012-03-01 19:56:54 -07:00
|
|
|
func (p *ProcessState) userTime() time.Duration {
|
2012-02-20 20:10:34 -07:00
|
|
|
return time.Duration(p.rusage.Utime.Nano()) * time.Nanosecond
|
|
|
|
}
|
|
|
|
|
2012-03-01 19:56:54 -07:00
|
|
|
func (p *ProcessState) systemTime() time.Duration {
|
2012-02-20 20:10:34 -07:00
|
|
|
return time.Duration(p.rusage.Stime.Nano()) * time.Nanosecond
|
|
|
|
}
|