io_pipe(3) [debian man page]

io_pipe(3)						     Library Functions Manual							io_pipe(3)

NAME

       io_pipe - create a Unix pipe

SYNTAX

       #include <io.h>

       int io_pipe(int64 pfd[2]);

DESCRIPTION

       io_pipe	creates  a  new UNIX ``pipe.'' The pipe can receive data and provide data; any bytes written to the pipe can then be read from the
       pipe in the same order.

       A pipe is typically stored in an 8192-byte memory buffer; the exact number depends on the UNIX kernel. Bytes are written to the end of  the
       buffer  and  read  from	the beginning of the buffer. Once a byte has been read, it is eliminated from the buffer, making space for another
       byte to be written; readers cannot ``rewind'' a pipe to read old data. Once 8192 bytes have been written to the buffer, the pipe  will  not
       be  ready for further writing until some of the bytes have been read. Once all the bytes written have been read, the pipe will not be ready
       for further reading until more bytes are written.

       io_pipe sets d[0] to the number of a new descriptor reading from the pipe, and sets d[1] to the number of a new descriptor writing  to  the
       pipe.  It then returns 1 to indicate success. If something goes wrong, io_pipe returns 0, setting errno to indicate the error; in this case
       it frees any memory that it allocated for the new pipe, and it leaves d alone.

SEE ALSO

       io_readfile(3), io_createfile(3), io_socketpair(3)

																	io_pipe(3)

PIPE(2) 							System Calls Manual							   PIPE(2)

NAME

       pipe - create an interprocess channel

SYNOPSIS

       #include <u.h>
       #include <libc.h>

       int pipe(int fd[2])

DESCRIPTION

       Pipe  creates  a  buffered  channel for interprocess I/O communication.	Two file descriptors are returned in fd.  Data written to fd[1] is
       available for reading from fd[0] and data written to fd[0] is available for reading from fd[1].

       After the pipe has been established, cooperating processes created by subsequent fork(2) calls may pass data through the pipe with read and
       write  calls.   The bytes placed on a pipe by one write are contiguous even if many processes are writing.  Write boundaries are preserved:
       each read terminates when the read buffer is full or after reading the last byte of a write, whichever comes first.

       The number of bytes available to a read(2) is reported in the Length field returned by fstat or dirfstat on a pipe (see stat(2)).

When all the data has been read from a pipe and the writer has closed the pipe or exited,
       read(2) will return 0 bytes.  Writes to a pipe with no reader will generate a note sys: write on closed pipe.

SOURCE

       /sys/src/libc/9syscall

SEE ALSO

       intro(2), read(2), pipe(3)

DIAGNOSTICS

       Sets errstr.

BUGS

       If a read or a write of a pipe is interrupted, some unknown number of bytes may have been transferred.
       When a read from a pipe returns 0 bytes, it usually means end of file but is indistinguishable from reading the result of an explicit write
       of zero bytes.

																	   PIPE(2)