}
	return p1, p2
}

func (*pipe) LocalAddr() Addr  { return pipeAddr{} }
func (*pipe) RemoteAddr() Addr { return pipeAddr{} }

func (p *pipe) Read(b []byte) (int, error) {
	n, err := p.read(b)
	if err != nil && err != io.EOF && err != io.ErrClosedPipe {
		err = &OpError{Op: "read", Net: "pipe", Err: err}
	}
	return n, err
}

func (p *pipe) read(b []byte) (n int, err error) {
	switch {

import (
	"log"
	"os"
	"runtime/trace"
	"syscall"
	"time"
)

func main() {
	// Create a pipe to block on.
	var p [2]int
	if err := syscall.Pipe(p[:]); err != nil {
		log.Fatalf("failed to create pipe: %v", err)
	}
	rfd, wfd := p[0], p[1]

	// Create a goroutine that blocks on the pipe.
	done := make(chan struct{})
	go func() {
		var data [1]byte
		_, err := syscall.Read(rfd, data[:])

- Kubeadm: default the kubeadm configuration to the containerd socket (Unix: `unix:///var/run/containerd/containerd.sock`, Windows: `npipe:////./pipe/containerd-containerd`) instead of the one for Docker. If the `Init|JoinConfiguration.nodeRegistration.criSocket` field is empty during cluster creation and multiple sockets are found on the host always throw an error and ask the user to specify...

		// but this shouldn't be a concern here, since the pipe buffer must contain inPipe size of
		// data on the basis of the workflow in Splice.
		n, err := splice(sock.Sysfd, pipefd, inPipe, spliceNonblock)
		if err == syscall.EINTR {
			continue
		}
		// Here, the condition n == 0 && err == nil should never be
		// observed, since Splice controls the write side of the pipe.
		if n > 0 {

	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 {

			break;
		}
		case 3: {
			if (verbose) {
				printf("attempting SIGPIPE\n");
			}

			int fd[2];
			if (pipe(fd) != 0) {
				printf("pipe(2) failed\n");
				return 0;
			}
			// Close the reading end.
			close(fd[0]);
			// Expect that write(2) fails (EPIPE)
			if (write(fd[1], "some data", 9) != -1) {
				printf("write(2) unexpectedly succeeded\n");
				return 0;
			}

- Windows runtime endpoints is now switched to `npipe:////./pipe/dockershim` from `tcp://localhost:3735`. ([#69516](https://github.com/kubernetes/kubernetes/pull/69516), [@feiskyer](https://github.com/feiskyer))

	}
	releaseForkLock()

	// Read child error status from pipe.
	Close(p[1])
	for {
		n, err = readlen(p[0], (*byte)(unsafe.Pointer(&err1)), int(unsafe.Sizeof(err1)))
		if err != EINTR {
			break
		}
	}
	Close(p[0])
	if err != nil || n != 0 {
		if n == int(unsafe.Sizeof(err1)) {
			err = Errno(err1)
		}
		if err == nil {
			err = EPIPE
		}

		// Child failed; wait for it to exit, to make sure

	EOWNERDEAD - APPLICATION_ERROR:      "owner died",
	EPERM - APPLICATION_ERROR:           "operation not permitted",
	EPFNOSUPPORT - APPLICATION_ERROR:    "protocol family not supported",
	EPIPE - APPLICATION_ERROR:           "broken pipe",
	EPROTO - APPLICATION_ERROR:          "protocol error",
	EPROTONOSUPPORT - APPLICATION_ERROR: "protocol not supported",
	EPROTOTYPE - APPLICATION_ERROR:      "protocol wrong type for socket",

	cmd = exec.Command(exe)
	var stdout strings.Builder
	var stderr strings.Builder
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr
	inPipe, err := cmd.StdinPipe()
	if err != nil {
		t.Fatalf("Failed to create stdin pipe: %v", err)
	}
	// keep inPipe alive until the end of the test
	defer inPipe.Close()

	// in a new command window
	const _CREATE_NEW_CONSOLE = 0x00000010
	cmd.SysProcAttr = &syscall.SysProcAttr{