func terminateProcessLoop(process syscall.Handle) error {
for waitResult := uint32(syscall.WAIT_TIMEOUT); waitResult == syscall.WAIT_TIMEOUT; {
syscall.TerminateProcess(process, 0)
waitResult, _ = syscall.WaitForSingleObject(process, 100)
}
return nil
}
func (sub *Subprocess) BottomHalf(d *SubprocessData, sig chan *SubprocessResult) {
hProcess := d.platformData.hProcess
hJob := d.platformData.hJob
result := &SubprocessResult{}
var waitResult uint32
waitResult = syscall.WAIT_TIMEOUT
var runState runningState
for result.SuccessCode == 0 && waitResult == syscall.WAIT_TIMEOUT {
waitResult, _ = syscall.WaitForSingleObject(hProcess, uint32(sub.TimeQuantum.Nanoseconds()/1000000))
if waitResult != syscall.WAIT_TIMEOUT {
break
}
_ = UpdateProcessTimes(&d.platformData, result, false)
if sub.MemoryLimit > 0 {
UpdateProcessMemory(&d.platformData, result)
}
runState.Update(sub, result)
}
switch waitResult {
case syscall.WAIT_OBJECT_0:
_ = syscall.GetExitCodeProcess(hProcess, &result.ExitCode)
case syscall.WAIT_TIMEOUT:
for waitResult == syscall.WAIT_TIMEOUT {
syscall.TerminateProcess(hProcess, 0)
waitResult, _ = syscall.WaitForSingleObject(hProcess, 100)
}
}
_ = UpdateProcessTimes(&d.platformData, result, true)
UpdateProcessMemory(&d.platformData, result)
syscall.CloseHandle(hProcess)
if hJob != syscall.InvalidHandle {
syscall.CloseHandle(hJob)
}
sub.SetPostLimits(result)
for _ = range d.startAfterStart {
err := <-d.bufferChan
if err != nil {
log.Error(err)
}
}
if d.stdOut.Len() > 0 {
result.Output = d.stdOut.Bytes()
}
if d.stdErr.Len() > 0 {
result.Error = d.stdErr.Bytes()
}
sig <- result
}
// Signal sends a signal to the Process.
func (p *Process) Signal(sig Signal) Error {
switch sig.(UnixSignal) {
case SIGKILL:
e := syscall.TerminateProcess(syscall.Handle(p.handle), 1)
return NewSyscallError("TerminateProcess", e)
}
return Errno(syscall.EWINDOWS)
}
func terminateProcess(pid, exitcode int) error {
h, e := syscall.OpenProcess(syscall.PROCESS_TERMINATE, false, uint32(pid))
if e != nil {
return NewSyscallError("OpenProcess", e)
}
defer syscall.CloseHandle(h)
e = syscall.TerminateProcess(h, uint32(exitcode))
return NewSyscallError("TerminateProcess", e)
}
// killProcess terminates a given pid using TerminateProcess.
func killProcess(pid uint32) error {
handle, err := syscall.OpenProcess(syscall.PROCESS_TERMINATE, false /* inheritHandle */, pid)
if err != nil {
return err
}
defer syscall.CloseHandle(handle)
log.VV("TerminateProcess(%v) with handle %v", pid, handle)
return syscall.TerminateProcess(handle, 1)
}
// Signal sends a signal to the Process.
func (p *Process) Signal(sig Signal) error {
if p.done {
return errors.New("os: process already finished")
}
if us, ok := sig.(UnixSignal); ok && us == syscall.SIGKILL {
e := syscall.TerminateProcess(syscall.Handle(p.handle), 1)
return NewSyscallError("TerminateProcess", e)
}
return syscall.Errno(syscall.EWINDOWS)
}
func (p *Process) signal(sig Signal) error {
if p.done {
return errors.New("os: process already finished")
}
if sig == Kill {
e := syscall.TerminateProcess(syscall.Handle(p.handle), 1)
return NewSyscallError("TerminateProcess", e)
}
// TODO(rsc): Handle Interrupt too?
return syscall.Errno(syscall.EWINDOWS)
}
// Signal sends a signal to the Process.
func (p *Process) Signal(sig Signal) error {
if p.done {
return errors.New("os: process already finished")
}
switch sig.(UnixSignal) {
case SIGKILL:
e := syscall.TerminateProcess(syscall.Handle(p.handle), 1)
return NewSyscallError("TerminateProcess", e)
}
return Errno(syscall.EWINDOWS)
}
// Kill kills the process.
func (dbp *Process) Kill() error {
if dbp.exited {
return nil
}
if !dbp.Threads[dbp.Pid].Stopped() {
return errors.New("process must be stopped in order to kill it")
}
// TODO: Should not have to ignore failures here,
// but some tests appear to Kill twice causing
// this to fail on second attempt.
_ = syscall.TerminateProcess(dbp.os.hProcess, 1)
dbp.exited = true
return nil
}
func killProcess(pid int) error {
const PROCESS_TERMINATE = 0x0001
const da = syscall.STANDARD_RIGHTS_READ |
syscall.PROCESS_QUERY_INFORMATION | syscall.SYNCHRONIZE | PROCESS_TERMINATE
h, e := syscall.OpenProcess(da, false, uint32(pid))
if e != nil {
return os.NewSyscallError("OpenProcess", e)
}
defer syscall.CloseHandle(h)
e = syscall.TerminateProcess(h, 1)
if nil != e {
return os.NewSyscallError("TerminateProcess", e)
}
return nil
}
func killProcess(pid int, handlePtr uintptr) {
syscall.TerminateProcess(syscall.Handle(handlePtr), 0)
}
