qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-23 18:40:03 -07:00
Code Releases Activity

os: use runtime.Keepalive for *Process values

Browse Source 
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>
This commit is contained in:
Ian Lance Taylor 2016-08-23 15:56:43 -07:00
parent 9be2a279ee
commit e69912e6f4
3 changed files with 5 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/os/exec_windows.go
View File

@ -63,7 +63,9 @@ func (p *Process) signal(sig Signal) error {
return errors.New("os: process already finished") return errors.New("os: process already finished")
} }
if sig == Kill { if sig == Kill {
return terminateProcess(p.Pid, 1) err := terminateProcess(p.Pid, 1)
runtime.KeepAlive(p)
return err
} }
// TODO(rsc): Handle Interrupt too? // TODO(rsc): Handle Interrupt too?
return syscall.Errno(syscall.EWINDOWS) return syscall.Errno(syscall.EWINDOWS)

1
src/os/wait_wait6.go
View File

@ -28,6 +28,7 @@ func (p *Process) blockUntilWaitable() (bool, error) {
} else { } else {
_, _, errno = syscall.Syscall6(syscall.SYS_WAIT6, _P_PID, uintptr(p.Pid), 0, syscall.WEXITED|syscall.WNOWAIT, 0, 0) _, _, errno = syscall.Syscall6(syscall.SYS_WAIT6, _P_PID, uintptr(p.Pid), 0, syscall.WEXITED|syscall.WNOWAIT, 0, 0)
} }
runtime.KeepAlive(p)
if errno != 0 { if errno != 0 {
// The wait6 system call is supported only on FreeBSD // The wait6 system call is supported only on FreeBSD
// 9.3 and above, so it may return an ENOSYS error. // 9.3 and above, so it may return an ENOSYS error.

2
src/os/wait_waitid.go
View File

@ -26,7 +26,7 @@ func (p *Process) blockUntilWaitable() (bool, error) {
var siginfo [128]byte var siginfo [128]byte
psig := &siginfo[0] psig := &siginfo[0]
_, _, e := syscall.Syscall6(syscall.SYS_WAITID, _P_PID, uintptr(p.Pid), uintptr(unsafe.Pointer(psig)), syscall.WEXITED|syscall.WNOWAIT, 0, 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 { if e != 0 {
// waitid has been available since Linux 2.6.9, but // waitid has been available since Linux 2.6.9, but
// reportedly is not available in Ubuntu on Windows. // reportedly is not available in Ubuntu on Windows.