diff options
author | Russ Cox <rsc@golang.org> | 2015-03-11 11:52:19 -0400 |
---|---|---|
committer | Russ Cox <rsc@golang.org> | 2015-03-16 23:07:06 +0000 |
commit | 0c31992eb3ee5a4faa424b22666098bd422117cd (patch) | |
tree | 56c28844136ddb6c614bd345d46af6f678b02c2d /test/recover4.go | |
parent | 5764befa5ace6e2dff623a79ba5a098d36fd1a86 (diff) | |
download | go-0c31992eb3ee5a4faa424b22666098bd422117cd.tar.gz go-0c31992eb3ee5a4faa424b22666098bd422117cd.zip |
test: add test that variables captured by deferred funcs are current on fault
This came up in private mail.
It works today and I want to make sure it stays working.
Change-Id: I13ebdc2dfadb3c72d7f179be89883137320c05d0
Reviewed-on: https://go-review.googlesource.com/7390
Reviewed-by: Austin Clements <austin@google.com>
Reviewed-by: Rob Pike <r@golang.org>
Diffstat (limited to 'test/recover4.go')
-rw-r--r-- | test/recover4.go | 71 |
1 files changed, 71 insertions, 0 deletions
diff --git a/test/recover4.go b/test/recover4.go new file mode 100644 index 0000000000..115d5a0eed --- /dev/null +++ b/test/recover4.go @@ -0,0 +1,71 @@ +// +build linux darwin +// run + +// 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. + +// Test that if a slice access causes a fault, a deferred func +// sees the most recent value of the variables it accesses. +// This is true today; the role of the test is to ensure it stays true. +// +// In the test, memcopy is the function that will fault, during dst[i] = src[i]. +// The deferred func recovers from the error and returns, making memcopy +// return the current value of n. If n is not being flushed to memory +// after each modification, the result will be a stale value of n. +// +// The test is set up by mmapping a 64 kB block of memory and then +// unmapping a 16 kB hole in the middle of it. Running memcopy +// on the resulting slice will fault when it reaches the hole. + +package main + +import ( + "log" + "runtime/debug" + "syscall" + "unsafe" +) + +func memcopy(dst, src []byte) (n int, err error) { + defer func() { + err = recover().(error) + }() + + for i := 0; i < len(dst) && i < len(src); i++ { + dst[i] = src[i] + n++ + } + return +} + +func main() { + // Turn the eventual fault into a panic, not a program crash, + // 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) + 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) + } + + 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) + 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) + } +} |