2 * Copyright (c) 1996 John S. Dyson
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice immediately at the beginning of the file, without modification,
10 * this list of conditions, and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. Absolutely no warranty of function or purpose is made by the author
16 * 4. Modifications may be freely made to this file if the above conditions
19 * $FreeBSD: src/sys/kern/sys_pipe.c,v 1.60.2.13 2002/08/05 15:05:15 des Exp $
23 * This file contains a high-performance replacement for the socket-based
24 * pipes scheme originally used in FreeBSD/4.4Lite. It does not support
25 * all features of sockets, but does do everything that pipes normally
28 #include <sys/param.h>
29 #include <sys/systm.h>
30 #include <sys/kernel.h>
32 #include <sys/fcntl.h>
34 #include <sys/filedesc.h>
35 #include <sys/filio.h>
36 #include <sys/ttycom.h>
38 #include <sys/signalvar.h>
39 #include <sys/sysproto.h>
41 #include <sys/vnode.h>
43 #include <sys/event.h>
44 #include <sys/globaldata.h>
45 #include <sys/module.h>
46 #include <sys/malloc.h>
47 #include <sys/sysctl.h>
48 #include <sys/socket.h>
51 #include <vm/vm_param.h>
53 #include <vm/vm_object.h>
54 #include <vm/vm_kern.h>
55 #include <vm/vm_extern.h>
57 #include <vm/vm_map.h>
58 #include <vm/vm_page.h>
59 #include <vm/vm_zone.h>
61 #include <sys/file2.h>
62 #include <sys/signal2.h>
64 #include <machine/cpufunc.h>
67 * interfaces to the outside world
69 static int pipe_read (struct file *fp, struct uio *uio,
70 struct ucred *cred, int flags);
71 static int pipe_write (struct file *fp, struct uio *uio,
72 struct ucred *cred, int flags);
73 static int pipe_close (struct file *fp);
74 static int pipe_shutdown (struct file *fp, int how);
75 static int pipe_kqfilter (struct file *fp, struct knote *kn);
76 static int pipe_stat (struct file *fp, struct stat *sb, struct ucred *cred);
77 static int pipe_ioctl (struct file *fp, u_long cmd, caddr_t data,
78 struct ucred *cred, struct sysmsg *msg);
80 static struct fileops pipeops = {
82 .fo_write = pipe_write,
83 .fo_ioctl = pipe_ioctl,
84 .fo_kqfilter = pipe_kqfilter,
86 .fo_close = pipe_close,
87 .fo_shutdown = pipe_shutdown
90 static void filt_pipedetach(struct knote *kn);
91 static int filt_piperead(struct knote *kn, long hint);
92 static int filt_pipewrite(struct knote *kn, long hint);
94 static struct filterops pipe_rfiltops =
95 { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_pipedetach, filt_piperead };
96 static struct filterops pipe_wfiltops =
97 { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_pipedetach, filt_pipewrite };
99 MALLOC_DEFINE(M_PIPE, "pipe", "pipe structures");
102 * Default pipe buffer size(s), this can be kind-of large now because pipe
103 * space is pageable. The pipe code will try to maintain locality of
104 * reference for performance reasons, so small amounts of outstanding I/O
105 * will not wipe the cache.
107 #define MINPIPESIZE (PIPE_SIZE/3)
108 #define MAXPIPESIZE (2*PIPE_SIZE/3)
111 * Limit the number of "big" pipes
113 #define LIMITBIGPIPES 64
114 #define PIPEQ_MAX_CACHE 16 /* per-cpu pipe structure cache */
116 static int pipe_maxbig = LIMITBIGPIPES;
117 static int pipe_maxcache = PIPEQ_MAX_CACHE;
118 static int pipe_bigcount;
119 static int pipe_nbig;
120 static int pipe_bcache_alloc;
121 static int pipe_bkmem_alloc;
122 static int pipe_rblocked_count;
123 static int pipe_wblocked_count;
125 SYSCTL_NODE(_kern, OID_AUTO, pipe, CTLFLAG_RW, 0, "Pipe operation");
126 SYSCTL_INT(_kern_pipe, OID_AUTO, nbig,
127 CTLFLAG_RD, &pipe_nbig, 0, "number of big pipes allocated");
128 SYSCTL_INT(_kern_pipe, OID_AUTO, bigcount,
129 CTLFLAG_RW, &pipe_bigcount, 0, "number of times pipe expanded");
130 SYSCTL_INT(_kern_pipe, OID_AUTO, rblocked,
131 CTLFLAG_RW, &pipe_rblocked_count, 0, "number of times pipe expanded");
132 SYSCTL_INT(_kern_pipe, OID_AUTO, wblocked,
133 CTLFLAG_RW, &pipe_wblocked_count, 0, "number of times pipe expanded");
134 SYSCTL_INT(_kern_pipe, OID_AUTO, maxcache,
135 CTLFLAG_RW, &pipe_maxcache, 0, "max pipes cached per-cpu");
136 SYSCTL_INT(_kern_pipe, OID_AUTO, maxbig,
137 CTLFLAG_RW, &pipe_maxbig, 0, "max number of big pipes");
138 static int pipe_delay = 5000; /* 5uS default */
139 SYSCTL_INT(_kern_pipe, OID_AUTO, delay,
140 CTLFLAG_RW, &pipe_delay, 0, "SMP delay optimization in ns");
141 #if !defined(NO_PIPE_SYSCTL_STATS)
142 SYSCTL_INT(_kern_pipe, OID_AUTO, bcache_alloc,
143 CTLFLAG_RW, &pipe_bcache_alloc, 0, "pipe buffer from pcpu cache");
144 SYSCTL_INT(_kern_pipe, OID_AUTO, bkmem_alloc,
145 CTLFLAG_RW, &pipe_bkmem_alloc, 0, "pipe buffer from kmem");
149 * Auto-size pipe cache to reduce kmem allocations and frees.
153 pipeinit(void *dummy)
155 size_t mbytes = kmem_lim_size();
157 if (pipe_maxbig == LIMITBIGPIPES) {
158 if (mbytes >= 7 * 1024)
160 if (mbytes >= 15 * 1024)
163 if (pipe_maxcache == PIPEQ_MAX_CACHE) {
164 if (mbytes >= 7 * 1024)
166 if (mbytes >= 15 * 1024)
170 SYSINIT(kmem, SI_BOOT2_MACHDEP, SI_ORDER_ANY, pipeinit, NULL)
172 static void pipeclose (struct pipe *cpipe);
173 static void pipe_free_kmem (struct pipe *cpipe);
174 static int pipe_create (struct pipe **cpipep);
175 static int pipespace (struct pipe *cpipe, int size);
178 pipewakeup(struct pipe *cpipe, int dosigio)
180 if (dosigio && (cpipe->pipe_state & PIPE_ASYNC) && cpipe->pipe_sigio) {
181 lwkt_gettoken(&proc_token);
182 pgsigio(cpipe->pipe_sigio, SIGIO, 0);
183 lwkt_reltoken(&proc_token);
185 KNOTE(&cpipe->pipe_kq.ki_note, 0);
189 * These routines are called before and after a UIO. The UIO
190 * may block, causing our held tokens to be lost temporarily.
192 * We use these routines to serialize reads against other reads
193 * and writes against other writes.
195 * The read token is held on entry so *ipp does not race.
198 pipe_start_uio(struct pipe *cpipe, int *ipp)
204 error = tsleep(ipp, PCATCH, "pipexx", 0);
213 pipe_end_uio(struct pipe *cpipe, int *ipp)
225 * The pipe system call for the DTYPE_PIPE type of pipes
227 * pipe_args(int dummy)
232 sys_pipe(struct pipe_args *uap)
234 struct thread *td = curthread;
235 struct filedesc *fdp = td->td_proc->p_fd;
236 struct file *rf, *wf;
237 struct pipe *rpipe, *wpipe;
240 rpipe = wpipe = NULL;
241 if (pipe_create(&rpipe) || pipe_create(&wpipe)) {
247 error = falloc(td->td_lwp, &rf, &fd1);
253 uap->sysmsg_fds[0] = fd1;
256 * Warning: once we've gotten past allocation of the fd for the
257 * read-side, we can only drop the read side via fdrop() in order
258 * to avoid races against processes which manage to dup() the read
259 * side while we are blocked trying to allocate the write side.
261 rf->f_type = DTYPE_PIPE;
262 rf->f_flag = FREAD | FWRITE;
263 rf->f_ops = &pipeops;
265 error = falloc(td->td_lwp, &wf, &fd2);
267 fsetfd(fdp, NULL, fd1);
269 /* rpipe has been closed by fdrop(). */
273 wf->f_type = DTYPE_PIPE;
274 wf->f_flag = FREAD | FWRITE;
275 wf->f_ops = &pipeops;
277 uap->sysmsg_fds[1] = fd2;
279 rpipe->pipe_slock = kmalloc(sizeof(struct lock),
280 M_PIPE, M_WAITOK|M_ZERO);
281 wpipe->pipe_slock = rpipe->pipe_slock;
282 rpipe->pipe_peer = wpipe;
283 wpipe->pipe_peer = rpipe;
284 lockinit(rpipe->pipe_slock, "pipecl", 0, 0);
287 * Once activated the peer relationship remains valid until
288 * both sides are closed.
290 fsetfd(fdp, rf, fd1);
291 fsetfd(fdp, wf, fd2);
299 * Allocate kva for pipe circular buffer, the space is pageable
300 * This routine will 'realloc' the size of a pipe safely, if it fails
301 * it will retain the old buffer.
302 * If it fails it will return ENOMEM.
305 pipespace(struct pipe *cpipe, int size)
307 struct vm_object *object;
311 npages = round_page(size) / PAGE_SIZE;
312 object = cpipe->pipe_buffer.object;
315 * [re]create the object if necessary and reserve space for it
316 * in the kernel_map. The object and memory are pageable. On
317 * success, free the old resources before assigning the new
320 if (object == NULL || object->size != npages) {
321 object = vm_object_allocate(OBJT_DEFAULT, npages);
322 buffer = (caddr_t)vm_map_min(&kernel_map);
324 error = vm_map_find(&kernel_map, object, 0,
325 (vm_offset_t *)&buffer,
327 1, VM_MAPTYPE_NORMAL,
328 VM_PROT_ALL, VM_PROT_ALL,
331 if (error != KERN_SUCCESS) {
332 vm_object_deallocate(object);
335 pipe_free_kmem(cpipe);
336 cpipe->pipe_buffer.object = object;
337 cpipe->pipe_buffer.buffer = buffer;
338 cpipe->pipe_buffer.size = size;
343 cpipe->pipe_buffer.rindex = 0;
344 cpipe->pipe_buffer.windex = 0;
349 * Initialize and allocate VM and memory for pipe, pulling the pipe from
350 * our per-cpu cache if possible. For now make sure it is sized for the
351 * smaller PIPE_SIZE default.
354 pipe_create(struct pipe **cpipep)
356 globaldata_t gd = mycpu;
360 if ((cpipe = gd->gd_pipeq) != NULL) {
361 gd->gd_pipeq = cpipe->pipe_peer;
363 cpipe->pipe_peer = NULL;
364 cpipe->pipe_wantwcnt = 0;
366 cpipe = kmalloc(sizeof(struct pipe), M_PIPE, M_WAITOK|M_ZERO);
369 if ((error = pipespace(cpipe, PIPE_SIZE)) != 0)
371 vfs_timestamp(&cpipe->pipe_ctime);
372 cpipe->pipe_atime = cpipe->pipe_ctime;
373 cpipe->pipe_mtime = cpipe->pipe_ctime;
374 lwkt_token_init(&cpipe->pipe_rlock, "piper");
375 lwkt_token_init(&cpipe->pipe_wlock, "pipew");
380 pipe_read(struct file *fp, struct uio *uio, struct ucred *cred, int fflags)
387 u_int size; /* total bytes available */
388 u_int nsize; /* total bytes to read */
389 u_int rindex; /* contiguous bytes available */
394 atomic_set_int(&curthread->td_mpflags, TDF_MP_BATCH_DEMARC);
396 if (uio->uio_resid == 0)
400 * Setup locks, calculate nbio
402 rpipe = (struct pipe *)fp->f_data;
403 wpipe = rpipe->pipe_peer;
404 lwkt_gettoken(&rpipe->pipe_rlock);
406 if (fflags & O_FBLOCKING)
408 else if (fflags & O_FNONBLOCKING)
410 else if (fp->f_flag & O_NONBLOCK)
416 * Reads are serialized. Note however that pipe_buffer.buffer and
417 * pipe_buffer.size can change out from under us when the number
418 * of bytes in the buffer are zero due to the write-side doing a
421 error = pipe_start_uio(rpipe, &rpipe->pipe_rip);
423 lwkt_reltoken(&rpipe->pipe_rlock);
428 bigread = (uio->uio_resid > 10 * 1024 * 1024);
431 while (uio->uio_resid) {
435 if (bigread && --bigcount == 0) {
438 if (CURSIG(curthread->td_lwp)) {
444 size = rpipe->pipe_buffer.windex - rpipe->pipe_buffer.rindex;
447 rindex = rpipe->pipe_buffer.rindex &
448 (rpipe->pipe_buffer.size - 1);
450 if (nsize > rpipe->pipe_buffer.size - rindex)
451 nsize = rpipe->pipe_buffer.size - rindex;
452 nsize = szmin(nsize, uio->uio_resid);
454 error = uiomove(&rpipe->pipe_buffer.buffer[rindex],
459 rpipe->pipe_buffer.rindex += nsize;
463 * If the FIFO is still over half full just continue
464 * and do not try to notify the writer yet.
466 if (size - nsize >= (rpipe->pipe_buffer.size >> 1)) {
472 * When the FIFO is less then half full notify any
473 * waiting writer. WANTW can be checked while
474 * holding just the rlock.
477 if ((rpipe->pipe_state & PIPE_WANTW) == 0)
482 * If the "write-side" was blocked we wake it up. This code
483 * is reached either when the buffer is completely emptied
484 * or if it becomes more then half-empty.
486 * Pipe_state can only be modified if both the rlock and
489 if (rpipe->pipe_state & PIPE_WANTW) {
490 lwkt_gettoken(&rpipe->pipe_wlock);
491 if (rpipe->pipe_state & PIPE_WANTW) {
492 rpipe->pipe_state &= ~PIPE_WANTW;
493 lwkt_reltoken(&rpipe->pipe_wlock);
496 lwkt_reltoken(&rpipe->pipe_wlock);
501 * Pick up our copy loop again if the writer sent data to
502 * us while we were messing around.
504 * On a SMP box poll up to pipe_delay nanoseconds for new
505 * data. Typically a value of 2000 to 4000 is sufficient
506 * to eradicate most IPIs/tsleeps/wakeups when a pipe
507 * is used for synchronous communications with small packets,
508 * and 8000 or so (8uS) will pipeline large buffer xfers
509 * between cpus over a pipe.
511 * For synchronous communications a hit means doing a
512 * full Awrite-Bread-Bwrite-Aread cycle in less then 2uS,
513 * where as miss requiring a tsleep/wakeup sequence
514 * will take 7uS or more.
516 if (rpipe->pipe_buffer.windex != rpipe->pipe_buffer.rindex)
519 #ifdef _RDTSC_SUPPORTED_
524 tsc_target = tsc_get_target(pipe_delay);
525 while (tsc_test_target(tsc_target) == 0) {
526 if (rpipe->pipe_buffer.windex !=
527 rpipe->pipe_buffer.rindex) {
538 * Detect EOF condition, do not set error.
540 if (rpipe->pipe_state & PIPE_REOF)
544 * Break if some data was read, or if this was a non-blocking
556 * Last chance, interlock with WANTR.
558 lwkt_gettoken(&rpipe->pipe_wlock);
559 size = rpipe->pipe_buffer.windex - rpipe->pipe_buffer.rindex;
561 lwkt_reltoken(&rpipe->pipe_wlock);
566 * Retest EOF - acquiring a new token can temporarily release
567 * tokens already held.
569 if (rpipe->pipe_state & PIPE_REOF) {
570 lwkt_reltoken(&rpipe->pipe_wlock);
575 * If there is no more to read in the pipe, reset its
576 * pointers to the beginning. This improves cache hit
579 * We need both locks to modify both pointers, and there
580 * must also not be a write in progress or the uiomove()
581 * in the write might block and temporarily release
582 * its wlock, then reacquire and update windex. We are
583 * only serialized against reads, not writes.
585 * XXX should we even bother resetting the indices? It
586 * might actually be more cache efficient not to.
588 if (rpipe->pipe_buffer.rindex == rpipe->pipe_buffer.windex &&
589 rpipe->pipe_wip == 0) {
590 rpipe->pipe_buffer.rindex = 0;
591 rpipe->pipe_buffer.windex = 0;
595 * Wait for more data.
597 * Pipe_state can only be set if both the rlock and wlock
600 rpipe->pipe_state |= PIPE_WANTR;
601 tsleep_interlock(rpipe, PCATCH);
602 lwkt_reltoken(&rpipe->pipe_wlock);
603 error = tsleep(rpipe, PCATCH | PINTERLOCKED, "piperd", 0);
604 ++pipe_rblocked_count;
608 pipe_end_uio(rpipe, &rpipe->pipe_rip);
611 * Uptime last access time
613 if (error == 0 && nread)
614 vfs_timestamp(&rpipe->pipe_atime);
617 * If we drained the FIFO more then half way then handle
618 * write blocking hysteresis.
620 * Note that PIPE_WANTW cannot be set by the writer without
621 * it holding both rlock and wlock, so we can test it
622 * while holding just rlock.
626 * Synchronous blocking is done on the pipe involved
628 if (rpipe->pipe_state & PIPE_WANTW) {
629 lwkt_gettoken(&rpipe->pipe_wlock);
630 if (rpipe->pipe_state & PIPE_WANTW) {
631 rpipe->pipe_state &= ~PIPE_WANTW;
632 lwkt_reltoken(&rpipe->pipe_wlock);
635 lwkt_reltoken(&rpipe->pipe_wlock);
640 * But we may also have to deal with a kqueue which is
641 * stored on the same pipe as its descriptor, so a
642 * EVFILT_WRITE event waiting for our side to drain will
643 * be on the other side.
645 lwkt_gettoken(&wpipe->pipe_wlock);
646 pipewakeup(wpipe, 0);
647 lwkt_reltoken(&wpipe->pipe_wlock);
649 /*size = rpipe->pipe_buffer.windex - rpipe->pipe_buffer.rindex;*/
650 lwkt_reltoken(&rpipe->pipe_rlock);
656 pipe_write(struct file *fp, struct uio *uio, struct ucred *cred, int fflags)
670 * Writes go to the peer. The peer will always exist.
672 rpipe = (struct pipe *) fp->f_data;
673 wpipe = rpipe->pipe_peer;
674 lwkt_gettoken(&wpipe->pipe_wlock);
675 if (wpipe->pipe_state & PIPE_WEOF) {
676 lwkt_reltoken(&wpipe->pipe_wlock);
681 * Degenerate case (EPIPE takes prec)
683 if (uio->uio_resid == 0) {
684 lwkt_reltoken(&wpipe->pipe_wlock);
689 * Writes are serialized (start_uio must be called with wlock)
691 error = pipe_start_uio(wpipe, &wpipe->pipe_wip);
693 lwkt_reltoken(&wpipe->pipe_wlock);
697 if (fflags & O_FBLOCKING)
699 else if (fflags & O_FNONBLOCKING)
701 else if (fp->f_flag & O_NONBLOCK)
707 * If it is advantageous to resize the pipe buffer, do
708 * so. We are write-serialized so we can block safely.
710 if ((wpipe->pipe_buffer.size <= PIPE_SIZE) &&
711 (pipe_nbig < pipe_maxbig) &&
712 wpipe->pipe_wantwcnt > 4 &&
713 (wpipe->pipe_buffer.rindex == wpipe->pipe_buffer.windex)) {
715 * Recheck after lock.
717 lwkt_gettoken(&wpipe->pipe_rlock);
718 if ((wpipe->pipe_buffer.size <= PIPE_SIZE) &&
719 (pipe_nbig < pipe_maxbig) &&
720 (wpipe->pipe_buffer.rindex == wpipe->pipe_buffer.windex)) {
721 atomic_add_int(&pipe_nbig, 1);
722 if (pipespace(wpipe, BIG_PIPE_SIZE) == 0)
725 atomic_subtract_int(&pipe_nbig, 1);
727 lwkt_reltoken(&wpipe->pipe_rlock);
730 orig_resid = uio->uio_resid;
733 bigwrite = (uio->uio_resid > 10 * 1024 * 1024);
736 while (uio->uio_resid) {
737 if (wpipe->pipe_state & PIPE_WEOF) {
745 if (bigwrite && --bigcount == 0) {
748 if (CURSIG(curthread->td_lwp)) {
754 windex = wpipe->pipe_buffer.windex &
755 (wpipe->pipe_buffer.size - 1);
756 space = wpipe->pipe_buffer.size -
757 (wpipe->pipe_buffer.windex - wpipe->pipe_buffer.rindex);
760 /* Writes of size <= PIPE_BUF must be atomic. */
761 if ((space < uio->uio_resid) && (orig_resid <= PIPE_BUF))
765 * Write to fill, read size handles write hysteresis. Also
766 * additional restrictions can cause select-based non-blocking
773 * Transfer size is minimum of uio transfer
774 * and free space in pipe buffer.
776 * Limit each uiocopy to no more then PIPE_SIZE
777 * so we can keep the gravy train going on a
778 * SMP box. This doubles the performance for
779 * write sizes > 16K. Otherwise large writes
780 * wind up doing an inefficient synchronous
783 space = szmin(space, uio->uio_resid);
784 if (space > PIPE_SIZE)
788 * First segment to transfer is minimum of
789 * transfer size and contiguous space in
790 * pipe buffer. If first segment to transfer
791 * is less than the transfer size, we've got
792 * a wraparound in the buffer.
794 segsize = wpipe->pipe_buffer.size - windex;
799 * If this is the first loop and the reader is
800 * blocked, do a preemptive wakeup of the reader.
802 * On SMP the IPI latency plus the wlock interlock
803 * on the reader side is the fastest way to get the
804 * reader going. (The scheduler will hard loop on
807 * NOTE: We can't clear WANTR here without acquiring
808 * the rlock, which we don't want to do here!
810 if ((wpipe->pipe_state & PIPE_WANTR))
814 * Transfer segment, which may include a wrap-around.
815 * Update windex to account for both all in one go
816 * so the reader can read() the data atomically.
818 error = uiomove(&wpipe->pipe_buffer.buffer[windex],
820 if (error == 0 && segsize < space) {
821 segsize = space - segsize;
822 error = uiomove(&wpipe->pipe_buffer.buffer[0],
828 wpipe->pipe_buffer.windex += space;
834 * We need both the rlock and the wlock to interlock against
835 * the EOF, WANTW, and size checks, and to modify pipe_state.
837 * These are token locks so we do not have to worry about
840 lwkt_gettoken(&wpipe->pipe_rlock);
843 * If the "read-side" has been blocked, wake it up now
844 * and yield to let it drain synchronously rather
847 if (wpipe->pipe_state & PIPE_WANTR) {
848 wpipe->pipe_state &= ~PIPE_WANTR;
853 * don't block on non-blocking I/O
856 lwkt_reltoken(&wpipe->pipe_rlock);
862 * re-test whether we have to block in the writer after
863 * acquiring both locks, in case the reader opened up
866 space = wpipe->pipe_buffer.size -
867 (wpipe->pipe_buffer.windex - wpipe->pipe_buffer.rindex);
869 if ((space < uio->uio_resid) && (orig_resid <= PIPE_BUF))
873 * Retest EOF - acquiring a new token can temporarily release
874 * tokens already held.
876 if (wpipe->pipe_state & PIPE_WEOF) {
877 lwkt_reltoken(&wpipe->pipe_rlock);
883 * We have no more space and have something to offer,
884 * wake up select/poll/kq.
887 wpipe->pipe_state |= PIPE_WANTW;
888 ++wpipe->pipe_wantwcnt;
889 pipewakeup(wpipe, 1);
890 if (wpipe->pipe_state & PIPE_WANTW)
891 error = tsleep(wpipe, PCATCH, "pipewr", 0);
892 ++pipe_wblocked_count;
894 lwkt_reltoken(&wpipe->pipe_rlock);
897 * Break out if we errored or the read side wants us to go
902 if (wpipe->pipe_state & PIPE_WEOF) {
907 pipe_end_uio(wpipe, &wpipe->pipe_wip);
910 * If we have put any characters in the buffer, we wake up
913 * Both rlock and wlock are required to be able to modify pipe_state.
915 if (wpipe->pipe_buffer.windex != wpipe->pipe_buffer.rindex) {
916 if (wpipe->pipe_state & PIPE_WANTR) {
917 lwkt_gettoken(&wpipe->pipe_rlock);
918 if (wpipe->pipe_state & PIPE_WANTR) {
919 wpipe->pipe_state &= ~PIPE_WANTR;
920 lwkt_reltoken(&wpipe->pipe_rlock);
923 lwkt_reltoken(&wpipe->pipe_rlock);
926 lwkt_gettoken(&wpipe->pipe_rlock);
927 pipewakeup(wpipe, 1);
928 lwkt_reltoken(&wpipe->pipe_rlock);
932 * Don't return EPIPE if I/O was successful
934 if ((wpipe->pipe_buffer.rindex == wpipe->pipe_buffer.windex) &&
935 (uio->uio_resid == 0) &&
941 vfs_timestamp(&wpipe->pipe_mtime);
944 * We have something to offer,
945 * wake up select/poll/kq.
947 /*space = wpipe->pipe_buffer.windex - wpipe->pipe_buffer.rindex;*/
948 lwkt_reltoken(&wpipe->pipe_wlock);
953 * we implement a very minimal set of ioctls for compatibility with sockets.
956 pipe_ioctl(struct file *fp, u_long cmd, caddr_t data,
957 struct ucred *cred, struct sysmsg *msg)
962 mpipe = (struct pipe *)fp->f_data;
964 lwkt_gettoken(&mpipe->pipe_rlock);
965 lwkt_gettoken(&mpipe->pipe_wlock);
970 mpipe->pipe_state |= PIPE_ASYNC;
972 mpipe->pipe_state &= ~PIPE_ASYNC;
977 *(int *)data = mpipe->pipe_buffer.windex -
978 mpipe->pipe_buffer.rindex;
982 error = fsetown(*(int *)data, &mpipe->pipe_sigio);
985 *(int *)data = fgetown(&mpipe->pipe_sigio);
989 /* This is deprecated, FIOSETOWN should be used instead. */
990 error = fsetown(-(*(int *)data), &mpipe->pipe_sigio);
994 /* This is deprecated, FIOGETOWN should be used instead. */
995 *(int *)data = -fgetown(&mpipe->pipe_sigio);
1002 lwkt_reltoken(&mpipe->pipe_wlock);
1003 lwkt_reltoken(&mpipe->pipe_rlock);
1012 pipe_stat(struct file *fp, struct stat *ub, struct ucred *cred)
1016 pipe = (struct pipe *)fp->f_data;
1018 bzero((caddr_t)ub, sizeof(*ub));
1019 ub->st_mode = S_IFIFO;
1020 ub->st_blksize = pipe->pipe_buffer.size;
1021 ub->st_size = pipe->pipe_buffer.windex - pipe->pipe_buffer.rindex;
1022 ub->st_blocks = (ub->st_size + ub->st_blksize - 1) / ub->st_blksize;
1023 ub->st_atimespec = pipe->pipe_atime;
1024 ub->st_mtimespec = pipe->pipe_mtime;
1025 ub->st_ctimespec = pipe->pipe_ctime;
1027 * Left as 0: st_dev, st_ino, st_nlink, st_uid, st_gid, st_rdev,
1029 * XXX (st_dev, st_ino) should be unique.
1035 pipe_close(struct file *fp)
1039 cpipe = (struct pipe *)fp->f_data;
1040 fp->f_ops = &badfileops;
1042 funsetown(&cpipe->pipe_sigio);
1048 * Shutdown one or both directions of a full-duplex pipe.
1051 pipe_shutdown(struct file *fp, int how)
1057 rpipe = (struct pipe *)fp->f_data;
1058 wpipe = rpipe->pipe_peer;
1061 * We modify pipe_state on both pipes, which means we need
1064 lwkt_gettoken(&rpipe->pipe_rlock);
1065 lwkt_gettoken(&rpipe->pipe_wlock);
1066 lwkt_gettoken(&wpipe->pipe_rlock);
1067 lwkt_gettoken(&wpipe->pipe_wlock);
1072 rpipe->pipe_state |= PIPE_REOF; /* my reads */
1073 rpipe->pipe_state |= PIPE_WEOF; /* peer writes */
1074 if (rpipe->pipe_state & PIPE_WANTR) {
1075 rpipe->pipe_state &= ~PIPE_WANTR;
1078 if (rpipe->pipe_state & PIPE_WANTW) {
1079 rpipe->pipe_state &= ~PIPE_WANTW;
1087 wpipe->pipe_state |= PIPE_REOF; /* peer reads */
1088 wpipe->pipe_state |= PIPE_WEOF; /* my writes */
1089 if (wpipe->pipe_state & PIPE_WANTR) {
1090 wpipe->pipe_state &= ~PIPE_WANTR;
1093 if (wpipe->pipe_state & PIPE_WANTW) {
1094 wpipe->pipe_state &= ~PIPE_WANTW;
1100 pipewakeup(rpipe, 1);
1101 pipewakeup(wpipe, 1);
1103 lwkt_reltoken(&wpipe->pipe_wlock);
1104 lwkt_reltoken(&wpipe->pipe_rlock);
1105 lwkt_reltoken(&rpipe->pipe_wlock);
1106 lwkt_reltoken(&rpipe->pipe_rlock);
1112 pipe_free_kmem(struct pipe *cpipe)
1114 if (cpipe->pipe_buffer.buffer != NULL) {
1115 if (cpipe->pipe_buffer.size > PIPE_SIZE)
1116 atomic_subtract_int(&pipe_nbig, 1);
1117 kmem_free(&kernel_map,
1118 (vm_offset_t)cpipe->pipe_buffer.buffer,
1119 cpipe->pipe_buffer.size);
1120 cpipe->pipe_buffer.buffer = NULL;
1121 cpipe->pipe_buffer.object = NULL;
1126 * Close the pipe. The slock must be held to interlock against simultanious
1127 * closes. The rlock and wlock must be held to adjust the pipe_state.
1130 pipeclose(struct pipe *cpipe)
1139 * The slock may not have been allocated yet (close during
1142 * We need both the read and write tokens to modify pipe_state.
1144 if (cpipe->pipe_slock)
1145 lockmgr(cpipe->pipe_slock, LK_EXCLUSIVE);
1146 lwkt_gettoken(&cpipe->pipe_rlock);
1147 lwkt_gettoken(&cpipe->pipe_wlock);
1150 * Set our state, wakeup anyone waiting in select/poll/kq, and
1151 * wakeup anyone blocked on our pipe.
1153 cpipe->pipe_state |= PIPE_CLOSED | PIPE_REOF | PIPE_WEOF;
1154 pipewakeup(cpipe, 1);
1155 if (cpipe->pipe_state & (PIPE_WANTR | PIPE_WANTW)) {
1156 cpipe->pipe_state &= ~(PIPE_WANTR | PIPE_WANTW);
1161 * Disconnect from peer.
1163 if ((ppipe = cpipe->pipe_peer) != NULL) {
1164 lwkt_gettoken(&ppipe->pipe_rlock);
1165 lwkt_gettoken(&ppipe->pipe_wlock);
1166 ppipe->pipe_state |= PIPE_REOF | PIPE_WEOF;
1167 pipewakeup(ppipe, 1);
1168 if (ppipe->pipe_state & (PIPE_WANTR | PIPE_WANTW)) {
1169 ppipe->pipe_state &= ~(PIPE_WANTR | PIPE_WANTW);
1172 if (SLIST_FIRST(&ppipe->pipe_kq.ki_note))
1173 KNOTE(&ppipe->pipe_kq.ki_note, 0);
1174 lwkt_reltoken(&ppipe->pipe_wlock);
1175 lwkt_reltoken(&ppipe->pipe_rlock);
1179 * If the peer is also closed we can free resources for both
1180 * sides, otherwise we leave our side intact to deal with any
1181 * races (since we only have the slock).
1183 if (ppipe && (ppipe->pipe_state & PIPE_CLOSED)) {
1184 cpipe->pipe_peer = NULL;
1185 ppipe->pipe_peer = NULL;
1186 ppipe->pipe_slock = NULL; /* we will free the slock */
1191 lwkt_reltoken(&cpipe->pipe_wlock);
1192 lwkt_reltoken(&cpipe->pipe_rlock);
1193 if (cpipe->pipe_slock)
1194 lockmgr(cpipe->pipe_slock, LK_RELEASE);
1197 * If we disassociated from our peer we can free resources
1199 if (ppipe == NULL) {
1201 if (cpipe->pipe_slock) {
1202 kfree(cpipe->pipe_slock, M_PIPE);
1203 cpipe->pipe_slock = NULL;
1205 if (gd->gd_pipeqcount >= pipe_maxcache ||
1206 cpipe->pipe_buffer.size != PIPE_SIZE
1208 pipe_free_kmem(cpipe);
1209 kfree(cpipe, M_PIPE);
1211 cpipe->pipe_state = 0;
1212 cpipe->pipe_peer = gd->gd_pipeq;
1213 gd->gd_pipeq = cpipe;
1214 ++gd->gd_pipeqcount;
1220 pipe_kqfilter(struct file *fp, struct knote *kn)
1224 cpipe = (struct pipe *)kn->kn_fp->f_data;
1226 switch (kn->kn_filter) {
1228 kn->kn_fop = &pipe_rfiltops;
1231 kn->kn_fop = &pipe_wfiltops;
1232 if (cpipe->pipe_peer == NULL) {
1233 /* other end of pipe has been closed */
1238 return (EOPNOTSUPP);
1240 kn->kn_hook = (caddr_t)cpipe;
1242 knote_insert(&cpipe->pipe_kq.ki_note, kn);
1248 filt_pipedetach(struct knote *kn)
1250 struct pipe *cpipe = (struct pipe *)kn->kn_hook;
1252 knote_remove(&cpipe->pipe_kq.ki_note, kn);
1257 filt_piperead(struct knote *kn, long hint)
1259 struct pipe *rpipe = (struct pipe *)kn->kn_fp->f_data;
1262 lwkt_gettoken(&rpipe->pipe_rlock);
1263 lwkt_gettoken(&rpipe->pipe_wlock);
1265 kn->kn_data = rpipe->pipe_buffer.windex - rpipe->pipe_buffer.rindex;
1267 if (rpipe->pipe_state & PIPE_REOF) {
1269 * Only set NODATA if all data has been exhausted
1271 if (kn->kn_data == 0)
1272 kn->kn_flags |= EV_NODATA;
1273 kn->kn_flags |= EV_EOF;
1277 lwkt_reltoken(&rpipe->pipe_wlock);
1278 lwkt_reltoken(&rpipe->pipe_rlock);
1281 ready = kn->kn_data > 0;
1288 filt_pipewrite(struct knote *kn, long hint)
1290 struct pipe *rpipe = (struct pipe *)kn->kn_fp->f_data;
1291 struct pipe *wpipe = rpipe->pipe_peer;
1295 if (wpipe == NULL) {
1296 kn->kn_flags |= (EV_EOF | EV_NODATA);
1300 lwkt_gettoken(&wpipe->pipe_rlock);
1301 lwkt_gettoken(&wpipe->pipe_wlock);
1303 if (wpipe->pipe_state & PIPE_WEOF) {
1304 kn->kn_flags |= (EV_EOF | EV_NODATA);
1309 kn->kn_data = wpipe->pipe_buffer.size -
1310 (wpipe->pipe_buffer.windex -
1311 wpipe->pipe_buffer.rindex);
1313 lwkt_reltoken(&wpipe->pipe_wlock);
1314 lwkt_reltoken(&wpipe->pipe_rlock);
1317 ready = kn->kn_data >= PIPE_BUF;