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 <mknyszek@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>

1 files changed, 15 insertions, 13 deletions

diff --git a/test/recover4.go b/test/recover4.go
index 67ed970ecb..7cab15a5a8 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)
 	}
 }