Source file src/os/pipe_test.go

Documentation: os

		 1  // Copyright 2015 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  // Test broken pipes on Unix systems.
		 6  //go:build !plan9 && !js
		 7  // +build !plan9,!js
		 8  
		 9  package os_test
		10  
		11  import (
		12  	"bufio"
		13  	"bytes"
		14  	"fmt"
		15  	"internal/testenv"
		16  	"io"
		17  	"io/fs"
		18  	"os"
		19  	osexec "os/exec"
		20  	"os/signal"
		21  	"runtime"
		22  	"strconv"
		23  	"strings"
		24  	"sync"
		25  	"syscall"
		26  	"testing"
		27  	"time"
		28  )
		29  
		30  func TestEPIPE(t *testing.T) {
		31  	r, w, err := os.Pipe()
		32  	if err != nil {
		33  		t.Fatal(err)
		34  	}
		35  	if err := r.Close(); err != nil {
		36  		t.Fatal(err)
		37  	}
		38  
		39  	expect := syscall.EPIPE
		40  	if runtime.GOOS == "windows" {
		41  		// 232 is Windows error code ERROR_NO_DATA, "The pipe is being closed".
		42  		expect = syscall.Errno(232)
		43  	}
		44  	// Every time we write to the pipe we should get an EPIPE.
		45  	for i := 0; i < 20; i++ {
		46  		_, err = w.Write([]byte("hi"))
		47  		if err == nil {
		48  			t.Fatal("unexpected success of Write to broken pipe")
		49  		}
		50  		if pe, ok := err.(*fs.PathError); ok {
		51  			err = pe.Err
		52  		}
		53  		if se, ok := err.(*os.SyscallError); ok {
		54  			err = se.Err
		55  		}
		56  		if err != expect {
		57  			t.Errorf("iteration %d: got %v, expected %v", i, err, expect)
		58  		}
		59  	}
		60  }
		61  
		62  func TestStdPipe(t *testing.T) {
		63  	switch runtime.GOOS {
		64  	case "windows":
		65  		t.Skip("Windows doesn't support SIGPIPE")
		66  	}
		67  	testenv.MustHaveExec(t)
		68  	r, w, err := os.Pipe()
		69  	if err != nil {
		70  		t.Fatal(err)
		71  	}
		72  	if err := r.Close(); err != nil {
		73  		t.Fatal(err)
		74  	}
		75  	// Invoke the test program to run the test and write to a closed pipe.
		76  	// If sig is false:
		77  	// writing to stdout or stderr should cause an immediate SIGPIPE;
		78  	// writing to descriptor 3 should fail with EPIPE and then exit 0.
		79  	// If sig is true:
		80  	// all writes should fail with EPIPE and then exit 0.
		81  	for _, sig := range []bool{false, true} {
		82  		for dest := 1; dest < 4; dest++ {
		83  			cmd := osexec.Command(os.Args[0], "-test.run", "TestStdPipeHelper")
		84  			cmd.Stdout = w
		85  			cmd.Stderr = w
		86  			cmd.ExtraFiles = []*os.File{w}
		87  			cmd.Env = append(os.Environ(), fmt.Sprintf("GO_TEST_STD_PIPE_HELPER=%d", dest))
		88  			if sig {
		89  				cmd.Env = append(cmd.Env, "GO_TEST_STD_PIPE_HELPER_SIGNAL=1")
		90  			}
		91  			if err := cmd.Run(); err == nil {
		92  				if !sig && dest < 3 {
		93  					t.Errorf("unexpected success of write to closed pipe %d sig %t in child", dest, sig)
		94  				}
		95  			} else if ee, ok := err.(*osexec.ExitError); !ok {
		96  				t.Errorf("unexpected exec error type %T: %v", err, err)
		97  			} else if ws, ok := ee.Sys().(syscall.WaitStatus); !ok {
		98  				t.Errorf("unexpected wait status type %T: %v", ee.Sys(), ee.Sys())
		99  			} else if ws.Signaled() && ws.Signal() == syscall.SIGPIPE {
	 100  				if sig || dest > 2 {
	 101  					t.Errorf("unexpected SIGPIPE signal for descriptor %d sig %t", dest, sig)
	 102  				}
	 103  			} else {
	 104  				t.Errorf("unexpected exit status %v for descriptor %d sig %t", err, dest, sig)
	 105  			}
	 106  		}
	 107  	}
	 108  
	 109  	// Test redirecting stdout but not stderr.	Issue 40076.
	 110  	cmd := osexec.Command(os.Args[0], "-test.run", "TestStdPipeHelper")
	 111  	cmd.Stdout = w
	 112  	var stderr bytes.Buffer
	 113  	cmd.Stderr = &stderr
	 114  	cmd.Env = append(os.Environ(), "GO_TEST_STD_PIPE_HELPER=1")
	 115  	if err := cmd.Run(); err == nil {
	 116  		t.Errorf("unexpected success of write to closed stdout")
	 117  	} else if ee, ok := err.(*osexec.ExitError); !ok {
	 118  		t.Errorf("unexpected exec error type %T: %v", err, err)
	 119  	} else if ws, ok := ee.Sys().(syscall.WaitStatus); !ok {
	 120  		t.Errorf("unexpected wait status type %T: %v", ee.Sys(), ee.Sys())
	 121  	} else if !ws.Signaled() || ws.Signal() != syscall.SIGPIPE {
	 122  		t.Errorf("unexpected exit status %v for write to closed stdout", err)
	 123  	}
	 124  	if output := stderr.Bytes(); len(output) > 0 {
	 125  		t.Errorf("unexpected output on stderr: %s", output)
	 126  	}
	 127  }
	 128  
	 129  // This is a helper for TestStdPipe. It's not a test in itself.
	 130  func TestStdPipeHelper(t *testing.T) {
	 131  	if os.Getenv("GO_TEST_STD_PIPE_HELPER_SIGNAL") != "" {
	 132  		signal.Notify(make(chan os.Signal, 1), syscall.SIGPIPE)
	 133  	}
	 134  	switch os.Getenv("GO_TEST_STD_PIPE_HELPER") {
	 135  	case "1":
	 136  		os.Stdout.Write([]byte("stdout"))
	 137  	case "2":
	 138  		os.Stderr.Write([]byte("stderr"))
	 139  	case "3":
	 140  		if _, err := os.NewFile(3, "3").Write([]byte("3")); err == nil {
	 141  			os.Exit(3)
	 142  		}
	 143  	default:
	 144  		t.Skip("skipping test helper")
	 145  	}
	 146  	// For stdout/stderr, we should have crashed with a broken pipe error.
	 147  	// The caller will be looking for that exit status,
	 148  	// so just exit normally here to cause a failure in the caller.
	 149  	// For descriptor 3, a normal exit is expected.
	 150  	os.Exit(0)
	 151  }
	 152  
	 153  func testClosedPipeRace(t *testing.T, read bool) {
	 154  	switch runtime.GOOS {
	 155  	case "freebsd":
	 156  		t.Skip("FreeBSD does not use the poller; issue 19093")
	 157  	}
	 158  
	 159  	limit := 1
	 160  	if !read {
	 161  		// Get the amount we have to write to overload a pipe
	 162  		// with no reader.
	 163  		limit = 131073
	 164  		if b, err := os.ReadFile("/proc/sys/fs/pipe-max-size"); err == nil {
	 165  			if i, err := strconv.Atoi(strings.TrimSpace(string(b))); err == nil {
	 166  				limit = i + 1
	 167  			}
	 168  		}
	 169  		t.Logf("using pipe write limit of %d", limit)
	 170  	}
	 171  
	 172  	r, w, err := os.Pipe()
	 173  	if err != nil {
	 174  		t.Fatal(err)
	 175  	}
	 176  	defer r.Close()
	 177  	defer w.Close()
	 178  
	 179  	// Close the read end of the pipe in a goroutine while we are
	 180  	// writing to the write end, or vice-versa.
	 181  	go func() {
	 182  		// Give the main goroutine a chance to enter the Read or
	 183  		// Write call. This is sloppy but the test will pass even
	 184  		// if we close before the read/write.
	 185  		time.Sleep(20 * time.Millisecond)
	 186  
	 187  		var err error
	 188  		if read {
	 189  			err = r.Close()
	 190  		} else {
	 191  			err = w.Close()
	 192  		}
	 193  		if err != nil {
	 194  			t.Error(err)
	 195  		}
	 196  	}()
	 197  
	 198  	b := make([]byte, limit)
	 199  	if read {
	 200  		_, err = r.Read(b[:])
	 201  	} else {
	 202  		_, err = w.Write(b[:])
	 203  	}
	 204  	if err == nil {
	 205  		t.Error("I/O on closed pipe unexpectedly succeeded")
	 206  	} else if pe, ok := err.(*fs.PathError); !ok {
	 207  		t.Errorf("I/O on closed pipe returned unexpected error type %T; expected fs.PathError", pe)
	 208  	} else if pe.Err != fs.ErrClosed {
	 209  		t.Errorf("got error %q but expected %q", pe.Err, fs.ErrClosed)
	 210  	} else {
	 211  		t.Logf("I/O returned expected error %q", err)
	 212  	}
	 213  }
	 214  
	 215  func TestClosedPipeRaceRead(t *testing.T) {
	 216  	testClosedPipeRace(t, true)
	 217  }
	 218  
	 219  func TestClosedPipeRaceWrite(t *testing.T) {
	 220  	testClosedPipeRace(t, false)
	 221  }
	 222  
	 223  // Issue 20915: Reading on nonblocking fd should not return "waiting
	 224  // for unsupported file type." Currently it returns EAGAIN; it is
	 225  // possible that in the future it will simply wait for data.
	 226  func TestReadNonblockingFd(t *testing.T) {
	 227  	switch runtime.GOOS {
	 228  	case "windows":
	 229  		t.Skip("Windows doesn't support SetNonblock")
	 230  	}
	 231  	if os.Getenv("GO_WANT_READ_NONBLOCKING_FD") == "1" {
	 232  		fd := syscallDescriptor(os.Stdin.Fd())
	 233  		syscall.SetNonblock(fd, true)
	 234  		defer syscall.SetNonblock(fd, false)
	 235  		_, err := os.Stdin.Read(make([]byte, 1))
	 236  		if err != nil {
	 237  			if perr, ok := err.(*fs.PathError); !ok || perr.Err != syscall.EAGAIN {
	 238  				t.Fatalf("read on nonblocking stdin got %q, should have gotten EAGAIN", err)
	 239  			}
	 240  		}
	 241  		os.Exit(0)
	 242  	}
	 243  
	 244  	testenv.MustHaveExec(t)
	 245  	r, w, err := os.Pipe()
	 246  	if err != nil {
	 247  		t.Fatal(err)
	 248  	}
	 249  	defer r.Close()
	 250  	defer w.Close()
	 251  	cmd := osexec.Command(os.Args[0], "-test.run="+t.Name())
	 252  	cmd.Env = append(os.Environ(), "GO_WANT_READ_NONBLOCKING_FD=1")
	 253  	cmd.Stdin = r
	 254  	output, err := cmd.CombinedOutput()
	 255  	t.Logf("%s", output)
	 256  	if err != nil {
	 257  		t.Errorf("child process failed: %v", err)
	 258  	}
	 259  }
	 260  
	 261  func TestCloseWithBlockingReadByNewFile(t *testing.T) {
	 262  	var p [2]syscallDescriptor
	 263  	err := syscall.Pipe(p[:])
	 264  	if err != nil {
	 265  		t.Fatal(err)
	 266  	}
	 267  	// os.NewFile returns a blocking mode file.
	 268  	testCloseWithBlockingRead(t, os.NewFile(uintptr(p[0]), "reader"), os.NewFile(uintptr(p[1]), "writer"))
	 269  }
	 270  
	 271  func TestCloseWithBlockingReadByFd(t *testing.T) {
	 272  	r, w, err := os.Pipe()
	 273  	if err != nil {
	 274  		t.Fatal(err)
	 275  	}
	 276  	// Calling Fd will put the file into blocking mode.
	 277  	_ = r.Fd()
	 278  	testCloseWithBlockingRead(t, r, w)
	 279  }
	 280  
	 281  // Test that we don't let a blocking read prevent a close.
	 282  func testCloseWithBlockingRead(t *testing.T, r, w *os.File) {
	 283  	defer r.Close()
	 284  	defer w.Close()
	 285  
	 286  	c1, c2 := make(chan bool), make(chan bool)
	 287  	var wg sync.WaitGroup
	 288  
	 289  	wg.Add(1)
	 290  	go func(c chan bool) {
	 291  		defer wg.Done()
	 292  		// Give the other goroutine a chance to enter the Read
	 293  		// or Write call. This is sloppy but the test will
	 294  		// pass even if we close before the read/write.
	 295  		time.Sleep(20 * time.Millisecond)
	 296  
	 297  		if err := r.Close(); err != nil {
	 298  			t.Error(err)
	 299  		}
	 300  		close(c)
	 301  	}(c1)
	 302  
	 303  	wg.Add(1)
	 304  	go func(c chan bool) {
	 305  		defer wg.Done()
	 306  		var b [1]byte
	 307  		_, err := r.Read(b[:])
	 308  		close(c)
	 309  		if err == nil {
	 310  			t.Error("I/O on closed pipe unexpectedly succeeded")
	 311  		}
	 312  		if pe, ok := err.(*fs.PathError); ok {
	 313  			err = pe.Err
	 314  		}
	 315  		if err != io.EOF && err != fs.ErrClosed {
	 316  			t.Errorf("got %v, expected EOF or closed", err)
	 317  		}
	 318  	}(c2)
	 319  
	 320  	for c1 != nil || c2 != nil {
	 321  		select {
	 322  		case <-c1:
	 323  			c1 = nil
	 324  			// r.Close has completed, but the blocking Read
	 325  			// is hanging. Close the writer to unblock it.
	 326  			w.Close()
	 327  		case <-c2:
	 328  			c2 = nil
	 329  		case <-time.After(1 * time.Second):
	 330  			switch {
	 331  			case c1 != nil && c2 != nil:
	 332  				t.Error("timed out waiting for Read and Close")
	 333  				w.Close()
	 334  			case c1 != nil:
	 335  				t.Error("timed out waiting for Close")
	 336  			case c2 != nil:
	 337  				t.Error("timed out waiting for Read")
	 338  			default:
	 339  				t.Error("impossible case")
	 340  			}
	 341  		}
	 342  	}
	 343  
	 344  	wg.Wait()
	 345  }
	 346  
	 347  // Issue 24164, for pipes.
	 348  func TestPipeEOF(t *testing.T) {
	 349  	r, w, err := os.Pipe()
	 350  	if err != nil {
	 351  		t.Fatal(err)
	 352  	}
	 353  
	 354  	var wg sync.WaitGroup
	 355  	wg.Add(1)
	 356  	go func() {
	 357  		defer wg.Done()
	 358  
	 359  		defer func() {
	 360  			if err := w.Close(); err != nil {
	 361  				t.Errorf("error closing writer: %v", err)
	 362  			}
	 363  		}()
	 364  
	 365  		for i := 0; i < 3; i++ {
	 366  			time.Sleep(10 * time.Millisecond)
	 367  			_, err := fmt.Fprintf(w, "line %d\n", i)
	 368  			if err != nil {
	 369  				t.Errorf("error writing to fifo: %v", err)
	 370  				return
	 371  			}
	 372  		}
	 373  		time.Sleep(10 * time.Millisecond)
	 374  	}()
	 375  
	 376  	defer wg.Wait()
	 377  
	 378  	done := make(chan bool)
	 379  	go func() {
	 380  		defer close(done)
	 381  
	 382  		defer func() {
	 383  			if err := r.Close(); err != nil {
	 384  				t.Errorf("error closing reader: %v", err)
	 385  			}
	 386  		}()
	 387  
	 388  		rbuf := bufio.NewReader(r)
	 389  		for {
	 390  			b, err := rbuf.ReadBytes('\n')
	 391  			if err == io.EOF {
	 392  				break
	 393  			}
	 394  			if err != nil {
	 395  				t.Error(err)
	 396  				return
	 397  			}
	 398  			t.Logf("%s\n", bytes.TrimSpace(b))
	 399  		}
	 400  	}()
	 401  
	 402  	select {
	 403  	case <-done:
	 404  		// Test succeeded.
	 405  	case <-time.After(time.Second):
	 406  		t.Error("timed out waiting for read")
	 407  		// Close the reader to force the read to complete.
	 408  		r.Close()
	 409  	}
	 410  }
	 411  
	 412  // Issue 24481.
	 413  func TestFdRace(t *testing.T) {
	 414  	r, w, err := os.Pipe()
	 415  	if err != nil {
	 416  		t.Fatal(err)
	 417  	}
	 418  	defer r.Close()
	 419  	defer w.Close()
	 420  
	 421  	var wg sync.WaitGroup
	 422  	call := func() {
	 423  		defer wg.Done()
	 424  		w.Fd()
	 425  	}
	 426  
	 427  	const tries = 100
	 428  	for i := 0; i < tries; i++ {
	 429  		wg.Add(1)
	 430  		go call()
	 431  	}
	 432  	wg.Wait()
	 433  }
	 434  
	 435  func TestFdReadRace(t *testing.T) {
	 436  	t.Parallel()
	 437  
	 438  	r, w, err := os.Pipe()
	 439  	if err != nil {
	 440  		t.Fatal(err)
	 441  	}
	 442  	defer r.Close()
	 443  	defer w.Close()
	 444  
	 445  	const count = 10
	 446  
	 447  	c := make(chan bool, 1)
	 448  	var wg sync.WaitGroup
	 449  	wg.Add(1)
	 450  	go func() {
	 451  		defer wg.Done()
	 452  		var buf [count]byte
	 453  		r.SetReadDeadline(time.Now().Add(time.Minute))
	 454  		c <- true
	 455  		if _, err := r.Read(buf[:]); os.IsTimeout(err) {
	 456  			t.Error("read timed out")
	 457  		}
	 458  	}()
	 459  
	 460  	wg.Add(1)
	 461  	go func() {
	 462  		defer wg.Done()
	 463  		<-c
	 464  		// Give the other goroutine a chance to enter the Read.
	 465  		// It doesn't matter if this occasionally fails, the test
	 466  		// will still pass, it just won't test anything.
	 467  		time.Sleep(10 * time.Millisecond)
	 468  		r.Fd()
	 469  
	 470  		// The bug was that Fd would hang until Read timed out.
	 471  		// If the bug is fixed, then writing to w and closing r here
	 472  		// will cause the Read to exit before the timeout expires.
	 473  		w.Write(make([]byte, count))
	 474  		r.Close()
	 475  	}()
	 476  
	 477  	wg.Wait()
	 478  }
	 479  

View as plain text