qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-22 17:54:45 -07:00
Code Releases Activity

test/recover4.go: use mprotect to create a hole instead of munmap

Browse Source 
Currently the recover4 test, which recovers from a panic created from a
fault, generates a fault by creating a hole in a mapping. It does this
via munmap. However, it's possible the runtime can create a new mapping
that ends up in that hole, for example if the GC executes, causing the
test to fail.

In fact, this is the case now with a smaller minimum heap size.

Modify the test to use mprotect, and clean up the code a little while
we're here: define everything in terms of the length of original
mapping, deduplicate some constants and expressions, and have the test
recover properly even if recover() returns nil (right now it panics
because it fails to type assert nil as error).

Fixes #49381.

Change-Id: If399eca564466e5e8aeb2dc6f86a246d0fce7b5d
Reviewed-on: https://go-review.googlesource.com/c/go/+/363534
Trust: Michael Knyszek <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
This commit is contained in:
Michael Anthony Knyszek 2021-11-12 05:04:32 +00:00 committed by Michael Knyszek
parent 23adc139bf
commit 95d0657670
1 changed files with 15 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
test/recover4.go
View File

@ -24,12 +24,13 @@ import (
"log"
"runtime/debug"
"syscall"
"unsafe"
)
func memcopy(dst, src []byte) (n int, err error) {
defer func() {
err = recover().(error)
if r, ok := recover().(error); ok {
err = r
}
}()
for i := 0; i < len(dst) && i < len(src); i++ {
@ -52,22 +53,23 @@ func main() {
log.Fatalf("mmap: %v", err)
}
other := make([]byte, 16*size)
// Note: Cannot call syscall.Munmap, because Munmap checks
// that you are unmapping a whole region returned by Mmap.
// We are trying to unmap just a hole in the middle.
if _, _, err := syscall.Syscall(syscall.SYS_MUNMAP, uintptr(unsafe.Pointer(&data[8*size])), uintptr(4*size), 0); err != 0 {
log.Fatalf("munmap: %v", err)
// Create a hole in the mapping that's PROT_NONE.
// Note that we can't use munmap here because the Go runtime
// could create a mapping that ends up in this hole otherwise,
// invalidating the test.
hole := data[len(data)/2 : 3*(len(data)/4)]
if err := syscall.Mprotect(hole, syscall.PROT_NONE); err != nil {
log.Fatalf("mprotect: %v", err)
}
// Check that memcopy returns the actual amount copied
// before the fault (8*size - 5, the offset we skip in the argument).
n, err := memcopy(data[5:], other)
// before the fault.
const offset = 5
n, err := memcopy(data[offset:], make([]byte, len(data)))
if err == nil {
log.Fatal("no error from memcopy across memory hole")
}
if n != 8*size-5 {
log.Fatalf("memcopy returned %d, want %d", n, 8*size-5)
if expect := len(data)/2 - offset; n != expect {
log.Fatalf("memcopy returned %d, want %d", n, expect)
}
}