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.
|
|
|
|
|
|
|
|
package os
|
|
|
|
|
|
|
|
import (
|
2011-11-01 20:12:41 -06:00
|
|
|
"errors"
|
2011-02-03 20:41:26 -07:00
|
|
|
"runtime"
|
|
|
|
"syscall"
|
2012-02-20 20:10:34 -07:00
|
|
|
"time"
|
2011-11-15 10:48:22 -07:00
|
|
|
"unsafe"
|
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-07-01 08:18:07 -06:00
|
|
|
s, e := syscall.WaitForSingleObject(syscall.Handle(p.handle), syscall.INFINITE)
|
2011-02-03 20:41:26 -07:00
|
|
|
switch s {
|
|
|
|
case syscall.WAIT_OBJECT_0:
|
|
|
|
break
|
|
|
|
case syscall.WAIT_FAILED:
|
|
|
|
return nil, NewSyscallError("WaitForSingleObject", e)
|
|
|
|
default:
|
2011-11-01 20:12:41 -06:00
|
|
|
return nil, errors.New("os: unexpected result from WaitForSingleObject")
|
2011-02-03 20:41:26 -07:00
|
|
|
}
|
|
|
|
var ec uint32
|
2011-07-01 08:18:07 -06:00
|
|
|
e = syscall.GetExitCodeProcess(syscall.Handle(p.handle), &ec)
|
2011-11-13 20:44:52 -07:00
|
|
|
if e != nil {
|
2011-02-03 20:41:26 -07:00
|
|
|
return nil, NewSyscallError("GetExitCodeProcess", e)
|
|
|
|
}
|
2012-03-01 20:47:40 -07:00
|
|
|
var u syscall.Rusage
|
|
|
|
e = syscall.GetProcessTimes(syscall.Handle(p.handle), &u.CreationTime, &u.ExitTime, &u.KernelTime, &u.UserTime)
|
|
|
|
if e != nil {
|
|
|
|
return nil, NewSyscallError("GetProcessTimes", e)
|
|
|
|
}
|
2011-07-11 16:47:42 -06:00
|
|
|
p.done = true
|
2012-03-01 22:35:42 -07:00
|
|
|
// NOTE(brainman): It seems that sometimes process is not dead
|
|
|
|
// when WaitForSingleObject returns. But we do not know any
|
|
|
|
// other way to wait for it. Sleeping for a while seems to do
|
|
|
|
// the trick sometimes. So we will sleep and smell the roses.
|
|
|
|
defer time.Sleep(5 * time.Millisecond)
|
2012-02-29 23:36:35 -07:00
|
|
|
defer p.Release()
|
2012-03-01 20:47:40 -07:00
|
|
|
return &ProcessState{p.Pid, syscall.WaitStatus{ExitCode: ec}, &u}, nil
|
2011-02-03 20:41:26 -07:00
|
|
|
}
|
|
|
|
|
2012-03-01 19:56:54 -07:00
|
|
|
func (p *Process) signal(sig Signal) error {
|
2011-07-11 16:47:42 -06:00
|
|
|
if p.done {
|
2011-11-01 20:12:41 -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
|
|
|
if sig == Kill {
|
2011-07-01 08:18:07 -06:00
|
|
|
e := syscall.TerminateProcess(syscall.Handle(p.handle), 1)
|
2011-06-06 03:53:30 -06:00
|
|
|
return NewSyscallError("TerminateProcess", e)
|
|
|
|
}
|
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
|
|
|
// TODO(rsc): Handle Interrupt too?
|
2011-11-13 20:44:52 -07:00
|
|
|
return syscall.Errno(syscall.EWINDOWS)
|
2011-06-06 03:53:30 -06:00
|
|
|
}
|
|
|
|
|
2012-02-29 23:36:35 -07:00
|
|
|
func (p *Process) release() error {
|
2012-02-02 12:08:48 -07:00
|
|
|
if p.handle == uintptr(syscall.InvalidHandle) {
|
2012-02-16 16:04:29 -07:00
|
|
|
return syscall.EINVAL
|
2011-02-03 20:41:26 -07:00
|
|
|
}
|
2011-07-01 08:18:07 -06:00
|
|
|
e := syscall.CloseHandle(syscall.Handle(p.handle))
|
2011-11-13 20:44:52 -07:00
|
|
|
if e != nil {
|
2011-02-03 20:41:26 -07:00
|
|
|
return NewSyscallError("CloseHandle", e)
|
|
|
|
}
|
2012-02-02 12:08:48 -07:00
|
|
|
p.handle = uintptr(syscall.InvalidHandle)
|
2011-02-03 20:41:26 -07:00
|
|
|
// 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
|
|
|
const da = syscall.STANDARD_RIGHTS_READ |
|
|
|
|
syscall.PROCESS_QUERY_INFORMATION | syscall.SYNCHRONIZE
|
|
|
|
h, e := syscall.OpenProcess(da, false, uint32(pid))
|
2011-11-13 20:44:52 -07:00
|
|
|
if e != nil {
|
2011-02-03 20:41:26 -07:00
|
|
|
return nil, NewSyscallError("OpenProcess", e)
|
|
|
|
}
|
2012-02-02 12:08:48 -07:00
|
|
|
return newProcess(pid, uintptr(h)), nil
|
2011-02-03 20:41:26 -07:00
|
|
|
}
|
2011-11-14 12:06:50 -07:00
|
|
|
|
|
|
|
func init() {
|
|
|
|
var argc int32
|
2011-11-15 10:48:22 -07:00
|
|
|
cmd := syscall.GetCommandLine()
|
|
|
|
argv, e := syscall.CommandLineToArgv(cmd, &argc)
|
2011-11-14 12:06:50 -07:00
|
|
|
if e != nil {
|
|
|
|
return
|
|
|
|
}
|
2011-11-15 10:48:22 -07:00
|
|
|
defer syscall.LocalFree(syscall.Handle(uintptr(unsafe.Pointer(argv))))
|
2011-11-14 12:06:50 -07:00
|
|
|
Args = make([]string, argc)
|
|
|
|
for i, v := range (*argv)[:argc] {
|
2011-11-15 10:48:22 -07:00
|
|
|
Args[i] = string(syscall.UTF16ToString((*v)[:]))
|
2011-11-14 12:06:50 -07:00
|
|
|
}
|
|
|
|
}
|
2012-02-20 20:10:34 -07:00
|
|
|
|
2012-03-01 20:47:40 -07:00
|
|
|
func ftToDuration(ft *syscall.Filetime) time.Duration {
|
|
|
|
n := int64(ft.HighDateTime)<<32 + int64(ft.LowDateTime) // in 100-nanosecond intervals
|
|
|
|
return time.Duration(n*100) * time.Nanosecond
|
|
|
|
}
|
2012-03-01 19:56:54 -07:00
|
|
|
|
|
|
|
func (p *ProcessState) userTime() time.Duration {
|
2012-03-01 20:47:40 -07:00
|
|
|
return ftToDuration(&p.rusage.UserTime)
|
2012-02-20 20:10:34 -07:00
|
|
|
}
|
|
|
|
|
2012-03-01 19:56:54 -07:00
|
|
|
func (p *ProcessState) systemTime() time.Duration {
|
2012-03-01 20:47:40 -07:00
|
|
|
return ftToDuration(&p.rusage.KernelTime)
|
2012-02-20 20:10:34 -07:00
|
|
|
}
|