From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 23 Aug 2016 22:56:43 +0000 (-0700)
Subject: os: use runtime.Keepalive for *Process values
X-Git-Tag: go1.8beta1~1661
X-Git-Url: http://www.git.cypherpunks.su/?a=commitdiff_plain;h=e69912e6f44b09d8bafde32f11642579272ab4af;p=gostls13.git

os: use runtime.Keepalive for *Process values

The os package sets a finalizer on *Process. I looked through all the
uses of *Process in the package, looking for each case where a *Process
was passed as an argument and the final reference to the argument was
not a function or method call. I added a call to runtime.KeepAlive after
each such final reference (there were only three).

The code is safe today without the KeepAlive calls because the compiler
keeps arguments alive for the duration of the function. However, that is
not a language requirement, so adding the KeepAlive calls ensures that
this code remains safe even if the compiler changes in the future.

I also removed an existing unnecessry call to runtime.KeepAlive. The
syscall.Syscall function is handled specially by the compiler to keep
its arguments alive.

Change-Id: Ibd2ff20b31ed3de4f6a59dd1633c1b44001d91d9
Reviewed-on: https://go-review.googlesource.com/27637
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
---

diff --git a/src/os/exec_windows.go b/src/os/exec_windows.go
index 72b5a93199..d89db2022c 100644
--- a/src/os/exec_windows.go
+++ b/src/os/exec_windows.go
@@ -63,7 +63,9 @@ func (p *Process) signal(sig Signal) error {
 		return errors.New("os: process already finished")
 	}
 	if sig == Kill {
-		return terminateProcess(p.Pid, 1)
+		err := terminateProcess(p.Pid, 1)
+		runtime.KeepAlive(p)
+		return err
 	}
 	// TODO(rsc): Handle Interrupt too?
 	return syscall.Errno(syscall.EWINDOWS)
diff --git a/src/os/wait_wait6.go b/src/os/wait_wait6.go
index 7f4780ae2d..b30981199e 100644
--- a/src/os/wait_wait6.go
+++ b/src/os/wait_wait6.go
@@ -28,6 +28,7 @@ func (p *Process) blockUntilWaitable() (bool, error) {
 	} else {
 		_, _, errno = syscall.Syscall6(syscall.SYS_WAIT6, _P_PID, uintptr(p.Pid), 0, syscall.WEXITED|syscall.WNOWAIT, 0, 0)
 	}
+	runtime.KeepAlive(p)
 	if errno != 0 {
 		// The wait6 system call is supported only on FreeBSD
 		// 9.3 and above, so it may return an ENOSYS error.
diff --git a/src/os/wait_waitid.go b/src/os/wait_waitid.go
index 74b7494c0d..653fce9253 100644
--- a/src/os/wait_waitid.go
+++ b/src/os/wait_waitid.go
@@ -26,7 +26,7 @@ func (p *Process) blockUntilWaitable() (bool, error) {
 	var siginfo [128]byte
 	psig := &siginfo[0]
 	_, _, e := syscall.Syscall6(syscall.SYS_WAITID, _P_PID, uintptr(p.Pid), uintptr(unsafe.Pointer(psig)), syscall.WEXITED|syscall.WNOWAIT, 0, 0)
-	runtime.KeepAlive(psig)
+	runtime.KeepAlive(p)
 	if e != 0 {
 		// waitid has been available since Linux 2.6.9, but
 		// reportedly is not available in Ubuntu on Windows.