From 95d06576702c54139796f3e24e2eec4b135b1a09 Mon Sep 17 00:00:00 2001 From: Michael Anthony Knyszek Date: Fri, 12 Nov 2021 05:04:32 +0000 Subject: [PATCH] test/recover4.go: use mprotect to create a hole instead of munmap 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 Run-TryBot: Michael Knyszek TryBot-Result: Go Bot Reviewed-by: Cherry Mui --- test/recover4.go | 28 +++++++++++++++------------- 1 file changed, 15 insertions(+), 13 deletions(-) diff --git a/test/recover4.go b/test/recover4.go index 67ed970ecb2..7cab15a5a81 100644 --- a/test/recover4.go +++ b/test/recover4.go @@ -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) } }