-// +build linux darwin
// run
-// Copyright 2015 The Go Authors. All rights reserved.
+//go:build linux || darwin
+
+// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
"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++ {
// so that memcopy can recover.
debug.SetPanicOnFault(true)
- // Map 64 kB block of data with 16 kB hole in middle.
- data, err := syscall.Mmap(-1, 0, 64*1024, syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_ANON|syscall.MAP_PRIVATE)
+ size := syscall.Getpagesize()
+
+ // Map 16 pages of data with a 4-page hole in the middle.
+ data, err := syscall.Mmap(-1, 0, 16*size, syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_ANON|syscall.MAP_PRIVATE)
if err != nil {
log.Fatalf("mmap: %v", err)
}
- // 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[32*1024])), 16*1024, 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)
}
- other := make([]byte, 64*1024)
-
// Check that memcopy returns the actual amount copied
- // before the fault (32kB - 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 != 32*1024-5 {
- log.Fatal("memcopy returned %d, want %d", n, 32*1024-5)
+ if expect := len(data)/2 - offset; n != expect {
+ log.Fatalf("memcopy returned %d, want %d", n, expect)
}
}