From 2f70ce36d79ee94855daf7c6feb9a1296f9adfac Mon Sep 17 00:00:00 2001 From: Jay Conrod Date: Mon, 20 Sep 2021 16:29:50 -0700 Subject: [PATCH] internal/fuzz: temporarily work around test failures after dev.fuzz merge - Skip test_fuzz_cache and test_fuzz_seed_corpus on 386. - Skip worker benchmarks when race mode is enabled. - Stub coverage function on platforms we haven't tested yet. It's causing package initialization to panic on aix/ppc64. For #48504 Change-Id: I79318b52b11a33fca66476b5050445d07422ef36 Reviewed-on: https://go-review.googlesource.com/c/go/+/351117 Trust: Jay Conrod Trust: Katie Hockman Run-TryBot: Jay Conrod TryBot-Result: Go Bot Reviewed-by: Katie Hockman --- .../go/testdata/script/test_fuzz_cache.txt | 3 ++ .../testdata/script/test_fuzz_seed_corpus.txt | 3 ++ src/internal/fuzz/counters_supported.go | 29 +++++++++++++++++++ src/internal/fuzz/counters_unsupported.go | 16 ++++++++++ src/internal/fuzz/coverage.go | 19 ------------ src/internal/fuzz/worker_test.go | 10 +++++++ 6 files changed, 61 insertions(+), 19 deletions(-) create mode 100644 src/internal/fuzz/counters_supported.go create mode 100644 src/internal/fuzz/counters_unsupported.go diff --git a/src/cmd/go/testdata/script/test_fuzz_cache.txt b/src/cmd/go/testdata/script/test_fuzz_cache.txt index 10e4c2926f4..8bcf2be61e3 100644 --- a/src/cmd/go/testdata/script/test_fuzz_cache.txt +++ b/src/cmd/go/testdata/script/test_fuzz_cache.txt @@ -1,6 +1,9 @@ # TODO(jayconrod): support shared memory on more platforms. [!darwin] [!linux] [!windows] skip +# TODO(#48504): fix and re-enable. +[linux] [386] skip + [short] skip env GOCACHE=$WORK/cache diff --git a/src/cmd/go/testdata/script/test_fuzz_seed_corpus.txt b/src/cmd/go/testdata/script/test_fuzz_seed_corpus.txt index 016b101d725..f810ad48d92 100644 --- a/src/cmd/go/testdata/script/test_fuzz_seed_corpus.txt +++ b/src/cmd/go/testdata/script/test_fuzz_seed_corpus.txt @@ -1,6 +1,9 @@ # TODO(jayconrod): support shared memory on more platforms. [!darwin] [!linux] [!windows] skip +# TODO(#48504): fix and re-enable. +[linux] [386] skip + [short] skip env GOCACHE=$WORK/cache diff --git a/src/internal/fuzz/counters_supported.go b/src/internal/fuzz/counters_supported.go new file mode 100644 index 00000000000..7ef553aaf2e --- /dev/null +++ b/src/internal/fuzz/counters_supported.go @@ -0,0 +1,29 @@ +// Copyright 2021 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. + +//go:build (darwin || linux || windows || freebsd) && (amd64 || arm64) + +package fuzz + +import ( + "internal/unsafeheader" + "unsafe" +) + +// coverage returns a []byte containing unique 8-bit counters for each edge of +// the instrumented source code. This coverage data will only be generated if +// `-d=libfuzzer` is set at build time. This can be used to understand the code +// coverage of a test execution. +func coverage() []byte { + addr := unsafe.Pointer(&_counters) + size := uintptr(unsafe.Pointer(&_ecounters)) - uintptr(addr) + + var res []byte + *(*unsafeheader.Slice)(unsafe.Pointer(&res)) = unsafeheader.Slice{ + Data: addr, + Len: int(size), + Cap: int(size), + } + return res +} diff --git a/src/internal/fuzz/counters_unsupported.go b/src/internal/fuzz/counters_unsupported.go new file mode 100644 index 00000000000..743ef45a660 --- /dev/null +++ b/src/internal/fuzz/counters_unsupported.go @@ -0,0 +1,16 @@ +// Copyright 2021 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. + +//go:build !((darwin || linux || windows || freebsd) && (amd64 || arm64)) + +package fuzz + +// TODO(#48504): re-enable on platforms where instrumentation works. +// This was disabled due to an init failure on aix_ppc64. + +// coverage returns a []byte containing unique 8-bit counters for each edge of +// the instrumented source code. This coverage data will only be generated if +// `-d=libfuzzer` is set at build time. This can be used to understand the code +// coverage of a test execution. +func coverage() []byte { return nil } diff --git a/src/internal/fuzz/coverage.go b/src/internal/fuzz/coverage.go index 71d0132e212..3dee73b81ce 100644 --- a/src/internal/fuzz/coverage.go +++ b/src/internal/fuzz/coverage.go @@ -6,28 +6,9 @@ package fuzz import ( "fmt" - "internal/unsafeheader" "math/bits" - "unsafe" ) -// coverage returns a []byte containing unique 8-bit counters for each edge of -// the instrumented source code. This coverage data will only be generated if -// `-d=libfuzzer` is set at build time. This can be used to understand the code -// coverage of a test execution. -func coverage() []byte { - addr := unsafe.Pointer(&_counters) - size := uintptr(unsafe.Pointer(&_ecounters)) - uintptr(addr) - - var res []byte - *(*unsafeheader.Slice)(unsafe.Pointer(&res)) = unsafeheader.Slice{ - Data: addr, - Len: int(size), - Cap: int(size), - } - return res -} - // ResetCovereage sets all of the counters for each edge of the instrumented // source code to 0. func ResetCoverage() { diff --git a/src/internal/fuzz/worker_test.go b/src/internal/fuzz/worker_test.go index 2369b4ce3f4..e32770b02ba 100644 --- a/src/internal/fuzz/worker_test.go +++ b/src/internal/fuzz/worker_test.go @@ -8,6 +8,7 @@ import ( "context" "flag" "fmt" + "internal/race" "io" "os" "os/signal" @@ -27,6 +28,9 @@ func TestMain(m *testing.M) { } func BenchmarkWorkerFuzzOverhead(b *testing.B) { + if race.Enabled { + b.Skip("TODO(48504): fix and re-enable") + } origEnv := os.Getenv("GODEBUG") defer func() { os.Setenv("GODEBUG", origEnv) }() os.Setenv("GODEBUG", fmt.Sprintf("%s,fuzzseed=123", origEnv)) @@ -65,6 +69,9 @@ func BenchmarkWorkerFuzzOverhead(b *testing.B) { // BenchmarkWorkerPing acts as the coordinator and measures the time it takes // a worker to respond to N pings. This is a rough measure of our RPC latency. func BenchmarkWorkerPing(b *testing.B) { + if race.Enabled { + b.Skip("TODO(48504): fix and re-enable") + } b.SetParallelism(1) w := newWorkerForTest(b) for i := 0; i < b.N; i++ { @@ -77,6 +84,9 @@ func BenchmarkWorkerPing(b *testing.B) { // BenchmarkWorkerFuzz acts as the coordinator and measures the time it takes // a worker to mutate a given input and call a trivial fuzz function N times. func BenchmarkWorkerFuzz(b *testing.B) { + if race.Enabled { + b.Skip("TODO(48504): fix and re-enable") + } b.SetParallelism(1) w := newWorkerForTest(b) entry := CorpusEntry{Values: []interface{}{[]byte(nil)}}