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 72b5a931999b2d86722731fcbfd2a27de608a08e..d89db2022ccb299a292f8621aade9eb55880a087 100644 (file)
--- 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 7f4780ae2d0ab8a9622f7629b68d1e66ece0dae8..b30981199e19f3fe55488944cff5cc29c7439d65 100644 (file)
--- 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 74b7494c0de8c2be91275b0debf20faa47856763..653fce92532508151053c4875d49ca8241e9746c 100644 (file)
--- 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.