32  * "normal" pipe buffering is done.  If the buffer is between PIPE_MINDIRECT
39  * is returned back to the user-mode side.  In that case, the pipe code
85  * both directions of a pipe.
112 #include <sys/pipe.h>
138 #define PIPE_PEER(pipe)	\  argument
139 	(((pipe)->pipe_type & PIPE_TYPE_NAMED) ? (pipe) : ((pipe)->pipe_peer))
201  * Default pipe buffer size(s), this can be kind-of large now because pipe
202  * space is pageable.  The pipe code will try to maintain locality of
218 	   &maxpipekva, 0, "Pipe KVA limit");
220 	   &amountpipekva, 0, "Pipe KVA usage");
222 	  &pipefragretry, 0, "Pipe allocation retries due to fragmentation");
224 	  &pipeallocfail, 0, "Pipe allocation failures");
226 	  &piperesizefail, 0, "Pipe resize failures");
228 	  &piperesizeallowed, 0, "Pipe resizing allowed");
231     "Superuser-reserved percentage of the pipe buffers space");
234 static void pipeclose(struct pipe *cpipe);
235 static void pipe_free_kmem(struct pipe *cpipe);
236 static int pipe_create(struct pipe *pipe, bool backing);
238 static __inline int pipelock(struct pipe *cpipe, bool catch);
239 static __inline void pipeunlock(struct pipe *cpipe);
242 static int pipe_build_write_buffer(struct pipe *wpipe, struct uio *uio);
243 static void pipe_destroy_write_buffer(struct pipe *wpipe);
244 static int pipe_direct_write(struct pipe *wpipe, struct uio *uio);
245 static void pipe_clone_write_buffer(struct pipe *wpipe);
247 static int pipespace(struct pipe *cpipe, int size);
248 static int pipespace_new(struct pipe *cpipe, int size);
264 	pipe_zone = uma_zcreate("pipe", sizeof(struct pipepair),  in pipeinit()
270 	KASSERT(pipedev_ino > 0, ("pipe dev inode not initialized"));  in pipeinit()
300 	struct pipe *rpipe, *wpipe;  in pipe_zone_ctor()
307 	 * We zero both pipe endpoints to make sure all the kmem pointers  in pipe_zone_ctor()
353 	mtx_init(&pp->pp_mtx, "pipe mutex", NULL, MTX_DEF | MTX_NEW);  in pipe_zone_init()
373 	struct pipe *rpipe, *wpipe;  in pipe_paircreate()
394 	 * Only the forward direction pipe is backed by big buffer by  in pipe_paircreate()
403 		 * This cleanup leaves the pipe inode number for rpipe  in pipe_paircreate()
431 pipe_named_ctor(struct pipe **ppipe, struct thread *td)  in pipe_named_ctor()
445 pipe_dtor(struct pipe *dpipe)  in pipe_dtor()
447 	struct pipe *peer;  in pipe_dtor()
473  * The pipe system call for the DTYPE_PIPE type of pipes.  If we fail, let
481 	struct pipe *rpipe, *wpipe;  in kern_pipe()
565  * Allocate kva for pipe circular buffer, the space is pageable
566  * This routine will 'realloc' the size of a pipe safely, if it fails
571 pipespace_new(struct pipe *cpipe, int size)  in pipespace_new()
578 	KASSERT(!mtx_owned(PIPE_MTX(cpipe)), ("pipespace: pipe mutex locked"));  in pipespace_new()
661 pipespace(struct pipe *cpipe, int size)  in pipespace()
665 	    ("Unlocked pipe passed to pipespace"));  in pipespace()
670  * lock a pipe for I/O, blocking other access
673 pipelock(struct pipe *cpipe, bool catch)  in pipelock()
698  * unlock a pipe I/O lock
701 pipeunlock(struct pipe *cpipe)  in pipeunlock()
706 		("Unlocked pipe passed to pipeunlock"));  in pipeunlock()
716 pipeselwakeup(struct pipe *cpipe)  in pipeselwakeup()
731  * Initialize and allocate VM and memory for pipe.  The structure
735 pipe_create(struct pipe *pipe, bool large_backing)  in pipe_create()  argument
739 	error = pipespace_new(pipe, !large_backing || amountpipekva >  in pipe_create()
742 		pipe->pipe_ino = alloc_unr64(&pipeino_unr);  in pipe_create()
751 	struct pipe *rpipe;  in pipe_read()
759 	 * Try to avoid locking the pipe if we have nothing to do.  in pipe_read()
761 	 * There are programs which share one pipe amongst multiple processes  in pipe_read()
762 	 * and perform non-blocking reads in parallel, even if the pipe is  in pipe_read()
800 		 * normal pipe buffer receive  in pipe_read()
824 			 * If there is no more to read in the pipe, reset  in pipe_read()
877 			 * Unlock the pipe buffer for our remaining processing.  in pipe_read()
947 pipe_build_write_buffer(struct pipe *wpipe, struct uio *uio)  in pipe_build_write_buffer()
956 	    ("%s: pipe map for %p contains residual data", __func__, wpipe));  in pipe_build_write_buffer()
994 pipe_destroy_write_buffer(struct pipe *wpipe)  in pipe_destroy_write_buffer()
1001 	    ("%s: pipe map for %p contains residual data", __func__, wpipe));  in pipe_destroy_write_buffer()
1014 pipe_clone_write_buffer(struct pipe *wpipe)  in pipe_clone_write_buffer()
1049  * This implements the pipe buffer write mechanism.  Note that only
1050  * a direct write OR a normal pipe write can be pending at any given time.
1051  * If there are any characters in the pipe buffer, the direct write will
1053  * the pipe buffer.  Then the direct mapping write is set-up.
1056 pipe_direct_write(struct pipe *wpipe, struct uio *uio)  in pipe_direct_write()
1129 	    ("pipe %p leaked PIPE_DIRECTW", wpipe));  in pipe_direct_write()
1142 	struct pipe *wpipe, *rpipe;  in pipe_write()
1155 	 * detect loss of pipe read side, issue SIGPIPE if lost.  in pipe_write()
1232 		 * Pipe buffered writes cannot be coincidental with  in pipe_write()
1235 		 * pipe buffer.  We break out if a signal occurs or the  in pipe_write()
1266 			 * and free space in pipe buffer.  in pipe_write()
1275 			 * pipe buffer.  If first segment to transfer  in pipe_write()
1294 					("Pipe buffer wraparound disappeared"));  in pipe_write()
1321 					("Pipe buffer overflow"));  in pipe_write()
1407 	struct pipe *cpipe;  in pipe_truncate()
1425 	struct pipe *mpipe = fp->f_data;  in pipe_ioctl()
1496 	struct pipe *rpipe;  in pipe_poll()
1497 	struct pipe *wpipe;  in pipe_poll()
1573 	struct pipe *pipe;  in pipe_stat()  local
1578 	pipe = fp->f_data;  in pipe_stat()
1581 		PIPE_LOCK(pipe);  in pipe_stat()
1582 		error = mac_pipe_check_stat(active_cred, pipe->pipe_pair);  in pipe_stat()
1583 		PIPE_UNLOCK(pipe);  in pipe_stat()
1591 	if (pipe->pipe_type & PIPE_TYPE_NAMED) {  in pipe_stat()
1598 	if (pipe->pipe_pages.cnt != 0)  in pipe_stat()
1599 		ub->st_size = pipe->pipe_pages.cnt;  in pipe_stat()
1601 		ub->st_size = pipe->pipe_buffer.cnt;  in pipe_stat()
1603 	ub->st_atim = pipe->pipe_atime;  in pipe_stat()
1604 	ub->st_mtim = pipe->pipe_mtime;  in pipe_stat()
1605 	ub->st_ctim = pipe->pipe_ctime;  in pipe_stat()
1609 	ub->st_ino = pipe->pipe_ino;  in pipe_stat()
1632 	struct pipe *cpipe;  in pipe_chmod()
1647 	struct pipe *cpipe;  in pipe_chown()
1661 	struct pipe *pi;  in pipe_fill_kinfo()
1677 pipe_free_kmem(struct pipe *cpipe)  in pipe_free_kmem()
1681 	    ("pipe_free_kmem: pipe mutex locked"));  in pipe_free_kmem()
1702  * shutdown the pipe
1705 pipeclose(struct pipe *cpipe)  in pipeclose()
1710 	struct pipe *ppipe;  in pipeclose()
1748 	 * doing that, or the pipe might disappear out from under  in pipeclose()
1769 	 * pipe pair.  If not, unlock.  in pipeclose()
1786 	struct pipe *cpipe;  in pipe_kqfilter()
1810 			/* other end of pipe has been closed */  in pipe_kqfilter()
1834 	struct pipe *cpipe = kn->kn_hook;  in filt_pipedetach()
1846 	struct pipe *rpipe = kn->kn_hook;  in filt_piperead()
1867 	struct pipe *wpipe = kn->kn_hook;  in filt_pipewrite()
1870 	 * If this end of the pipe is closed, the knote was removed from the  in filt_pipewrite()
1871 	 * knlist and the list lock (i.e., the pipe lock) is therefore not held.  in filt_pipewrite()
1913 	struct pipe *pipe = kn->kn_hook;  in filt_pipedump()  local
1916 	kin->knt_pipe.knt_pipe_ino = pipe->pipe_ino;  in filt_pipedump()