From ccd992355df7192993c666236047820244914598 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Tue, 16 Apr 2024 21:19:13 +0200 Subject: Adding upstream version 1.21.8. Signed-off-by: Daniel Baumann --- src/os/pipe_test.go | 478 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 478 insertions(+) create mode 100644 src/os/pipe_test.go (limited to 'src/os/pipe_test.go') diff --git a/src/os/pipe_test.go b/src/os/pipe_test.go new file mode 100644 index 0000000..6f01d30 --- /dev/null +++ b/src/os/pipe_test.go @@ -0,0 +1,478 @@ +// 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 broken pipes on Unix systems. +// +//go:build !plan9 && !js && !wasip1 + +package os_test + +import ( + "bufio" + "bytes" + "fmt" + "internal/testenv" + "io" + "io/fs" + "os" + "os/exec" + "os/signal" + "runtime" + "strconv" + "strings" + "sync" + "syscall" + "testing" + "time" +) + +func TestEPIPE(t *testing.T) { + // This test cannot be run in parallel because of a race similar + // to the one reported in https://go.dev/issue/22315. + // + // Even though the pipe is opened with O_CLOEXEC, if another test forks in + // between the call to os.Pipe and the call to r.Close, that child process can + // retain an open copy of r's file descriptor until it execs. If one of our + // Write calls occurs during that interval it can spuriously succeed, + // buffering the write to the child's copy of the pipe (even though the child + // will not actually read the buffered bytes). + + r, w, err := os.Pipe() + if err != nil { + t.Fatal(err) + } + if err := r.Close(); err != nil { + t.Fatal(err) + } + + expect := syscall.EPIPE + if runtime.GOOS == "windows" { + // 232 is Windows error code ERROR_NO_DATA, "The pipe is being closed". + expect = syscall.Errno(232) + } + // Every time we write to the pipe we should get an EPIPE. + for i := 0; i < 20; i++ { + _, err = w.Write([]byte("hi")) + if err == nil { + t.Fatal("unexpected success of Write to broken pipe") + } + if pe, ok := err.(*fs.PathError); ok { + err = pe.Err + } + if se, ok := err.(*os.SyscallError); ok { + err = se.Err + } + if err != expect { + t.Errorf("iteration %d: got %v, expected %v", i, err, expect) + } + } +} + +func TestStdPipe(t *testing.T) { + switch runtime.GOOS { + case "windows": + t.Skip("Windows doesn't support SIGPIPE") + } + + if os.Getenv("GO_TEST_STD_PIPE_HELPER") != "" { + if os.Getenv("GO_TEST_STD_PIPE_HELPER_SIGNAL") != "" { + signal.Notify(make(chan os.Signal, 1), syscall.SIGPIPE) + } + switch os.Getenv("GO_TEST_STD_PIPE_HELPER") { + case "1": + os.Stdout.Write([]byte("stdout")) + case "2": + os.Stderr.Write([]byte("stderr")) + case "3": + if _, err := os.NewFile(3, "3").Write([]byte("3")); err == nil { + os.Exit(3) + } + default: + panic("unrecognized value for GO_TEST_STD_PIPE_HELPER") + } + // For stdout/stderr, we should have crashed with a broken pipe error. + // The caller will be looking for that exit status, + // so just exit normally here to cause a failure in the caller. + // For descriptor 3, a normal exit is expected. + os.Exit(0) + } + + testenv.MustHaveExec(t) + // This test cannot be run in parallel due to the same race as for TestEPIPE. + // (We expect a write to a closed pipe can fail, but a concurrent fork of a + // child process can cause the pipe to unexpectedly remain open.) + + r, w, err := os.Pipe() + if err != nil { + t.Fatal(err) + } + if err := r.Close(); err != nil { + t.Fatal(err) + } + // Invoke the test program to run the test and write to a closed pipe. + // If sig is false: + // writing to stdout or stderr should cause an immediate SIGPIPE; + // writing to descriptor 3 should fail with EPIPE and then exit 0. + // If sig is true: + // all writes should fail with EPIPE and then exit 0. + for _, sig := range []bool{false, true} { + for dest := 1; dest < 4; dest++ { + cmd := testenv.Command(t, os.Args[0], "-test.run", "TestStdPipe") + cmd.Stdout = w + cmd.Stderr = w + cmd.ExtraFiles = []*os.File{w} + cmd.Env = append(os.Environ(), fmt.Sprintf("GO_TEST_STD_PIPE_HELPER=%d", dest)) + if sig { + cmd.Env = append(cmd.Env, "GO_TEST_STD_PIPE_HELPER_SIGNAL=1") + } + if err := cmd.Run(); err == nil { + if !sig && dest < 3 { + t.Errorf("unexpected success of write to closed pipe %d sig %t in child", dest, sig) + } + } else if ee, ok := err.(*exec.ExitError); !ok { + t.Errorf("unexpected exec error type %T: %v", err, err) + } else if ws, ok := ee.Sys().(syscall.WaitStatus); !ok { + t.Errorf("unexpected wait status type %T: %v", ee.Sys(), ee.Sys()) + } else if ws.Signaled() && ws.Signal() == syscall.SIGPIPE { + if sig || dest > 2 { + t.Errorf("unexpected SIGPIPE signal for descriptor %d sig %t", dest, sig) + } + } else { + t.Errorf("unexpected exit status %v for descriptor %d sig %t", err, dest, sig) + } + } + } + + // Test redirecting stdout but not stderr. Issue 40076. + cmd := testenv.Command(t, os.Args[0], "-test.run", "TestStdPipe") + cmd.Stdout = w + var stderr bytes.Buffer + cmd.Stderr = &stderr + cmd.Env = append(cmd.Environ(), "GO_TEST_STD_PIPE_HELPER=1") + if err := cmd.Run(); err == nil { + t.Errorf("unexpected success of write to closed stdout") + } else if ee, ok := err.(*exec.ExitError); !ok { + t.Errorf("unexpected exec error type %T: %v", err, err) + } else if ws, ok := ee.Sys().(syscall.WaitStatus); !ok { + t.Errorf("unexpected wait status type %T: %v", ee.Sys(), ee.Sys()) + } else if !ws.Signaled() || ws.Signal() != syscall.SIGPIPE { + t.Errorf("unexpected exit status %v for write to closed stdout", err) + } + if output := stderr.Bytes(); len(output) > 0 { + t.Errorf("unexpected output on stderr: %s", output) + } +} + +func testClosedPipeRace(t *testing.T, read bool) { + // This test cannot be run in parallel due to the same race as for TestEPIPE. + // (We expect a write to a closed pipe can fail, but a concurrent fork of a + // child process can cause the pipe to unexpectedly remain open.) + + limit := 1 + if !read { + // Get the amount we have to write to overload a pipe + // with no reader. + limit = 131073 + if b, err := os.ReadFile("/proc/sys/fs/pipe-max-size"); err == nil { + if i, err := strconv.Atoi(strings.TrimSpace(string(b))); err == nil { + limit = i + 1 + } + } + t.Logf("using pipe write limit of %d", limit) + } + + r, w, err := os.Pipe() + if err != nil { + t.Fatal(err) + } + defer r.Close() + defer w.Close() + + // Close the read end of the pipe in a goroutine while we are + // writing to the write end, or vice-versa. + go func() { + // Give the main goroutine a chance to enter the Read or + // Write call. This is sloppy but the test will pass even + // if we close before the read/write. + time.Sleep(20 * time.Millisecond) + + var err error + if read { + err = r.Close() + } else { + err = w.Close() + } + if err != nil { + t.Error(err) + } + }() + + b := make([]byte, limit) + if read { + _, err = r.Read(b[:]) + } else { + _, err = w.Write(b[:]) + } + if err == nil { + t.Error("I/O on closed pipe unexpectedly succeeded") + } else if pe, ok := err.(*fs.PathError); !ok { + t.Errorf("I/O on closed pipe returned unexpected error type %T; expected fs.PathError", pe) + } else if pe.Err != fs.ErrClosed { + t.Errorf("got error %q but expected %q", pe.Err, fs.ErrClosed) + } else { + t.Logf("I/O returned expected error %q", err) + } +} + +func TestClosedPipeRaceRead(t *testing.T) { + testClosedPipeRace(t, true) +} + +func TestClosedPipeRaceWrite(t *testing.T) { + testClosedPipeRace(t, false) +} + +// Issue 20915: Reading on nonblocking fd should not return "waiting +// for unsupported file type." Currently it returns EAGAIN; it is +// possible that in the future it will simply wait for data. +func TestReadNonblockingFd(t *testing.T) { + switch runtime.GOOS { + case "windows": + t.Skip("Windows doesn't support SetNonblock") + } + if os.Getenv("GO_WANT_READ_NONBLOCKING_FD") == "1" { + fd := syscallDescriptor(os.Stdin.Fd()) + syscall.SetNonblock(fd, true) + defer syscall.SetNonblock(fd, false) + _, err := os.Stdin.Read(make([]byte, 1)) + if err != nil { + if perr, ok := err.(*fs.PathError); !ok || perr.Err != syscall.EAGAIN { + t.Fatalf("read on nonblocking stdin got %q, should have gotten EAGAIN", err) + } + } + os.Exit(0) + } + + testenv.MustHaveExec(t) + t.Parallel() + + r, w, err := os.Pipe() + if err != nil { + t.Fatal(err) + } + defer r.Close() + defer w.Close() + cmd := testenv.Command(t, os.Args[0], "-test.run="+t.Name()) + cmd.Env = append(cmd.Environ(), "GO_WANT_READ_NONBLOCKING_FD=1") + cmd.Stdin = r + output, err := cmd.CombinedOutput() + t.Logf("%s", output) + if err != nil { + t.Errorf("child process failed: %v", err) + } +} + +func TestCloseWithBlockingReadByNewFile(t *testing.T) { + t.Parallel() + + var p [2]syscallDescriptor + err := syscall.Pipe(p[:]) + if err != nil { + t.Fatal(err) + } + // os.NewFile returns a blocking mode file. + testCloseWithBlockingRead(t, os.NewFile(uintptr(p[0]), "reader"), os.NewFile(uintptr(p[1]), "writer")) +} + +func TestCloseWithBlockingReadByFd(t *testing.T) { + t.Parallel() + + r, w, err := os.Pipe() + if err != nil { + t.Fatal(err) + } + // Calling Fd will put the file into blocking mode. + _ = r.Fd() + testCloseWithBlockingRead(t, r, w) +} + +// Test that we don't let a blocking read prevent a close. +func testCloseWithBlockingRead(t *testing.T, r, w *os.File) { + var ( + enteringRead = make(chan struct{}) + done = make(chan struct{}) + ) + go func() { + var b [1]byte + close(enteringRead) + _, err := r.Read(b[:]) + if err == nil { + t.Error("I/O on closed pipe unexpectedly succeeded") + } + + if pe, ok := err.(*fs.PathError); ok { + err = pe.Err + } + if err != io.EOF && err != fs.ErrClosed { + t.Errorf("got %v, expected EOF or closed", err) + } + close(done) + }() + + // Give the goroutine a chance to enter the Read + // or Write call. This is sloppy but the test will + // pass even if we close before the read/write. + <-enteringRead + time.Sleep(20 * time.Millisecond) + + if err := r.Close(); err != nil { + t.Error(err) + } + // r.Close has completed, but since we assume r is in blocking mode that + // probably didn't unblock the call to r.Read. Close w to unblock it. + w.Close() + <-done +} + +func TestPipeEOF(t *testing.T) { + t.Parallel() + + r, w, err := os.Pipe() + if err != nil { + t.Fatal(err) + } + + testPipeEOF(t, r, w) +} + +// testPipeEOF tests that when the write side of a pipe or FIFO is closed, +// a blocked Read call on the reader side returns io.EOF. +// +// This scenario previously failed to unblock the Read call on darwin. +// (See https://go.dev/issue/24164.) +func testPipeEOF(t *testing.T, r io.ReadCloser, w io.WriteCloser) { + // parkDelay is an arbitrary delay we wait for a pipe-reader goroutine to park + // before issuing the corresponding write. The test should pass no matter what + // delay we use, but with a longer delay is has a higher chance of detecting + // poller bugs. + parkDelay := 10 * time.Millisecond + if testing.Short() { + parkDelay = 100 * time.Microsecond + } + writerDone := make(chan struct{}) + defer func() { + if err := r.Close(); err != nil { + t.Errorf("error closing reader: %v", err) + } + <-writerDone + }() + + write := make(chan int, 1) + go func() { + defer close(writerDone) + + for i := range write { + time.Sleep(parkDelay) + _, err := fmt.Fprintf(w, "line %d\n", i) + if err != nil { + t.Errorf("error writing to fifo: %v", err) + return + } + } + + time.Sleep(parkDelay) + if err := w.Close(); err != nil { + t.Errorf("error closing writer: %v", err) + } + }() + + rbuf := bufio.NewReader(r) + for i := 0; i < 3; i++ { + write <- i + b, err := rbuf.ReadBytes('\n') + if err != nil { + t.Fatal(err) + } + t.Logf("%s\n", bytes.TrimSpace(b)) + } + + close(write) + b, err := rbuf.ReadBytes('\n') + if err != io.EOF || len(b) != 0 { + t.Errorf(`ReadBytes: %q, %v; want "", io.EOF`, b, err) + } +} + +// Issue 24481. +func TestFdRace(t *testing.T) { + // This test starts 100 simultaneous goroutines, which could bury a more + // interesting stack if this or some other test happens to panic. It is also + // nearly instantaneous, so any latency benefit from running it in parallel + // would be minimal. + + r, w, err := os.Pipe() + if err != nil { + t.Fatal(err) + } + defer r.Close() + defer w.Close() + + var wg sync.WaitGroup + call := func() { + defer wg.Done() + w.Fd() + } + + const tries = 100 + for i := 0; i < tries; i++ { + wg.Add(1) + go call() + } + wg.Wait() +} + +func TestFdReadRace(t *testing.T) { + t.Parallel() + + r, w, err := os.Pipe() + if err != nil { + t.Fatal(err) + } + defer r.Close() + defer w.Close() + + const count = 10 + + c := make(chan bool, 1) + var wg sync.WaitGroup + wg.Add(1) + go func() { + defer wg.Done() + var buf [count]byte + r.SetReadDeadline(time.Now().Add(time.Minute)) + c <- true + if _, err := r.Read(buf[:]); os.IsTimeout(err) { + t.Error("read timed out") + } + }() + + wg.Add(1) + go func() { + defer wg.Done() + <-c + // Give the other goroutine a chance to enter the Read. + // It doesn't matter if this occasionally fails, the test + // will still pass, it just won't test anything. + time.Sleep(10 * time.Millisecond) + r.Fd() + + // The bug was that Fd would hang until Read timed out. + // If the bug is fixed, then writing to w and closing r here + // will cause the Read to exit before the timeout expires. + w.Write(make([]byte, count)) + r.Close() + }() + + wg.Wait() +} -- cgit v1.2.3