CVS log for src/sys/sys/pipe.h

Up to [cvs.NetBSD.org] / src / sys / sys

Request diff between arbitrary revisions

Keyword substitution: kv
Default branch: MAIN

Back out the following revisions on behalf of core:

	sys/sys/lwp.h: revision 1.228
	sys/sys/pipe.h: revision 1.40
	sys/kern/uipc_socket.c: revision 1.306
	sys/kern/kern_sleepq.c: revision 1.84
	sys/rump/librump/rumpkern/locks_up.c: revision 1.13
	sys/kern/sys_pipe.c: revision 1.165
	usr.bin/fstat/fstat.c: revision 1.119
	sys/rump/librump/rumpkern/locks.c: revision 1.87
	sys/ddb/db_xxx.c: revision 1.78
	sys/ddb/db_command.c: revision 1.187
	sys/sys/condvar.h: revision 1.18
	sys/ddb/db_interface.h: revision 1.42
	sys/sys/socketvar.h: revision 1.166
	sys/kern/uipc_syscalls.c: revision 1.209
	sys/kern/kern_condvar.c: revision 1.60

  Add cv_fdrestart() [...]
  Use cv_fdrestart() to implement fo_restart.
  Simplify/streamline pipes a little bit [...]

This changes have caused regressions and need to be debugged.
The cv_fdrestart() addition needs more discussion.

sys/pipe.h: #define<tab>

No functional change intended.

Simplify/streamline pipes a little bit:

- Allocate only one struct pipe not two (no need to be bidirectional here).
- Then use f_flag (FREAD/FWRITE) to figure out what to do in the fileops.
- Never wake the other side or acquire long-term (I/O) lock unless needed.
- Whenever possible, defer wakeups until after locks have been released.
- Do some things locklessly in pipe_ioctl() and pipe_poll().

Some notable results:

- -30% latency on a 486DX2/66 doing 1 byte ping-pong within a single process.
- 2.5x less lock contention during "make cleandir" of src on a 48 CPU machine.
- 1.5x bandwith with 1kB messages on the same 48 CPU machine (8kB: same b/w).

pipe->pipe_waiters isn't needed on NetBSD, kernel condvars do this for free.

Sync with HEAD.

Fix a thundering herd problem in pipes.

Wake only one waiter when data becomes available, not all of them.
Waking them all is not a usual case, but turns up with make's job
token pipes. (Probably make's job signalling scheme should also be
revised, assuming rillig hasn't already done that, but that's a
separate issue.)

This change will not do us much good for the moment because we don't
distinguish cv_signal from cv_broadcast for interruptible sleeps, but
that's also a separate problem.

Seen on FreeBSD; from mjg at freebsd a couple months ago. Patch was
mine (iirc) but the real work in this sort of thing is discovering the
problem.

remove experimental direct pipe code (using uvm_loan()) I added in 2001 - it's
slower than the non-direct variant on MP systems, if anybody wants
to hack on this further it's available in Attic

Sync with HEAD

Sync with HEAD

Resolve a couple of conflicts (result of the uimin/uimax changes)

- Cleanup for dynamic sysctl:
  - Remove unused *_NAMES macros for sysctl.
  - Remove unused *_MAXID for sysctls.
- Move CTL_MACHDEP sysctl definitions for m68k into m68k/include/cpu.h and
  use them on all m68k machines.

Sync with HEAD

convert the (still disabled) 'direct write' for pipes to use the
experimental PMAP_DIRECT if available; the direct code paths now survive
longer than the pmap_enter() variant, but still triggers panic during
build.sh tools run; remove some obsolete sysctls

add some XXXs to mark places which need attention to make this more stable

Note: the loan case is now actually significantly slower than the
non-loan case on MP systems, due to synchronous IPIs triggered by
marking the page read-only by uvm_loan(); this is being discussed
in the email thread
https://mail-index.netbsd.org/tech-kern/2018/05/21/msg023441.html

that is basically the same issue due to which loaning was disabled
for sosend()

Sync with HEAD

Remove emap support. Unfortunately it never got to state where it would be
used and usable, due to reliability and limited & complicated MD support.

Going forward, we need to concentrate on interface which do not map anything
into kernel in first place (such as direct map or KVA-less I/O), rather
than making those mappings cheaper to do.

update from HEAD

Sync with HEAD

Needs struct timespec.

sync with head

If a multithreaded app closes an fd while another thread is blocked in
read/write/accept, then the expectation is that the blocked thread will
exit and the close complete.
Since only one fd is affected, but many fd can refer to the same file,
the close code can only request the fs code unblock with ERESTART.
Fixed for pipes and sockets, ERESTART will only be generated after such
a close - so there should be no change for other programs.
Also rename fo_abort() to fo_restart() (this used to be fo_drain()).
Fixes PR/26567

Revert most of the previous change.
Only one fd needs clobbering, not all fds that reference the pipe.
This may be what ad@ realised when he tried to add the same code to
sockets. Unfixes part of PR/26567.

Add support for unblocking read/write when close called.
Fixes PR/26567 for pipes.
(NB ad backed out the fix for sockets)

include prerequisite headers

Sync with HEAD.

sync with head.

Ephemeral mapping (emap) implementation.  Concept is based on the idea that
activity of other threads will perform the TLB flush for the processes using
emap as a side effect.  To track that, global and per-CPU generation numbers
are used.  This idea was suggested by Andrew Doran; various improvements to
it by me.  Notes:

- For now, zero-copy on pipe is not yet enabled.
- TCP socket code would likely need more work.
- Additional UVM loaning improvements are needed.

Proposed on <tech-kern>, silence there.
Quickly reviewed by <ad>.

Sync with HEAD.

Commit is split, to avoid a "too many arguments" protocol error.

sync with head.

Sync with HEAD.

rename ctime to btime for consistency.

- maintain timespec internally.
- set birthtime too.

Sync with HEAD.

Pull up following revision(s) (requested by enami/joerg in ticket #468):
	sys/kern/sys_pipe.c: revision 1.106
	sys/sys/pipe.h: revision 1.25
Apply pipe patch posted to tech-kern, slightly updated:
- Cache kva.
- Convert to use mutex_obj_alloc().
- Make better use of pool_cache.
Also:
Disable direct transfers for the moment. I believe there may be a bug that
can cause transfers to stall when switching between direct/buffered access.
I think this has most recently been run into on 'denver' but I have seen it
as far back as 3.1.
(As an aside, direct is a not a clear win on modern systems with large cache
and high TLB invalidation overhead. Particularly so on MP systems, although
micro benchmarks may report otherwise because they typically do not tax the
system. Anyone want to write a decent benchmark?)

Apply pipe patch posted to tech-kern, slightly updated:

- Cache kva.
- Convert to use mutex_obj_alloc().
- Make better use of pool_cache.

Also:

Disable direct transfers for the moment. I believe there may be a bug that
can cause transfers to stall when switching between direct/buffered access.
I think this has most recently been run into on 'denver' but I have seen it
as far back as 3.1.

(As an aside, direct is a not a clear win on modern systems with large cache
and high TLB invalidation overhead. Particularly so on MP systems, although
micro benchmarks may report otherwise because they typically do not tax the
system. Anyone want to write a decent benchmark?)

Sync with HEAD.

sync with head.

sync with HEAD

sync with head.

fix a livelock with multiple readers by separating condvar.

Sync with HEAD.

sync with head

sync with HEAD

Sync with HEAD

remove PIPE_WANTW, PIPE_WANTR and PIPE_WANTCLOSE.  cv_waiters is enough.
this fixes a deadlock between pipe_direct_write and pipeclose.

XXX this code should be simplified.
it's mostly pointless to have two struct pipes linked together,
esp. when we don't support bi-directional pipes.

Merge more changes from vmlocking2, mainly:

- Locking improvements.
- Use pool_cache for more items.

Share a single mutex between both ends of the pipe and remove all the
crappy code that deals with locking in the wrong direction.

sync with head.

Sync with head.

sync with head.

Sync with head.

Put a lock around pipe->pipe_peer.

Use mutexes & condvars.

Sync with HEAD.

Kill caddr_t; there will be some MI fallout, but it will be fixed shortly.

sync with head.

merge ktrace-lwp.

Sync with HEAD. Here we go again...

sync with head.

just use ltsleep rather than lockmgr + PCATCH with horrible timeout dance.

sync with -current

Sync with HEAD.

sync with head.  xen and whitespace.  xen part is not finished.

A couple of <sys/select.h>-related changes:
* Factor out struct selinfo and its header dependencies into its own header,
  <sys/selinfo.h>, to avoid namespace pollution.
* Include <sys/selinfo.h> in user-visible headers where necessary.

sync with head.

Sync with HEAD.

de-__P

Fix the sync with head I botched.

Sync with HEAD.

Sync with HEAD

Initialise (most) pools from a link set instead of explicit calls
to pool_init.  Untouched pools are ones that either in arch-specific
code, or aren't initialiased during initial system startup.

 Convert struct session, ucred and lockf to pools.

Make the pipe code mostly MP-safe.  There are a few unaddressed race
conditions at points where it's necessary to access both the up-stream
and down-stream parts of the bi-directional pipe data structure. These
are marked `XXXSMP' in the code.

Also, since the changes are pretty invasive, there little point in keeping
all the "#ifdef FreeBSD" code around; so all of that has been stripped out.

sync kqueue branch with HEAD

catch up with -current.

Catch up to -current.

use 'pid_t' for pipe_pgid, rather that 'gid_t'
this fixes the code in pipeselwakeup() to properly send signal to process group

Problem found by Anders Magnusson, using gcc 3.2 with pdp-10 target.

Catch up to -current.
(CVS: It's not just a program. It's an adventure!)

Catch up with -current.

add NetBSD RCS tag

Merge in FreeBSD rev. 1.18 - MP changes + rename of PIPE_LOCK to PIPE_LOCKFL
XXXSMP the MP hooks are unused on NetBSD for now

put NetBSD kernel-only parts into #ifdef _KERNEL

Import updated <sys/pipe.h> from FreeBSD rev. 1.18.
The only change is MP stuff (FreeBSD specific).

Sync kqueue branch with -current.

Catch up to -current.

Sync the thorpej-mips-cache branch with -current.

use pmap_kenter_pa() instead of pmap_enter(), this is required for
pages loaned to the kernel.  this implies that we also need to
call pmap_kremove() before uvm_km_free().

other general cleanup:  remove argument names from prototypes,
rename some variables, etc.

Use hardcoded 8192 for PIPE_MINDIRECT, rather than being dependant
on PAGE_SIZE. The overhead of setting up Page Loan is pretty much constant
irregardless of page size, so it makes more sense to use fixed constant.

According to hbench, the overhead of Page Loan setup is still significantly
bigger than the performance gain for 4096 byte buffers on i386
(PIII/600Mhz). The difference is smaller on 386DX, but Page Loan is
still not faster for this case.

Also, there is some other code out there which expects 4KB writes
to not block even for 'blocking' write, since it works this
way on some other operating systems.
Partially addresses kern/14246 by Andreas Persson.

Catch up with -current.

update to -current

define BIG_PIPE_SIZE value using PIPE_SIZE

#include <sys/select> implicitly in !_KERNEL case

Move CTL_PIPE_NAMES and KERN_PIPE_* from <sys/sysctl.h> to <sys/pipe.h>

g/c PIPE_MOREW

Catch up to -current.

file pipe.h was added on branch nathanw_sa on 2001-06-21 20:09:50 +0000

Move prototype of sysctl_dopipe() from <sys/sysctl.h> to <sys/pipe.h>
and adjust kern/kern_sysctl.c accordingly.

Add port of high performance pipe implementation written by John S. Dyson
for FreeBSD project. Besides huge speed boost compared with socketpair-based
pipes, this implementation also uses pagable kernel memory instead of mbufs.

Significant differences to FreeBSD version:
* uses uvm_loan() facility for direct write
* async/SIGIO handling correct also for sync writer, async reader
* limits settable via sysctl, amountpipekva and nbigpipes available via sysctl
* pipes are unidirectional - this is enforced on file descriptor level
	for now only, the code would be updated to take advantage of it
	eventually
* uses lockmgr(9)-based locks instead of home brew variant
* scatter-gather write is handled correctly for direct write case, data
  is transferred by PIPE_DIRECT_CHUNK bytes maximum, to avoid running out of kva

All FreeBSD/NetBSD specific code is within appropriate #ifdef, in preparation
to feed changes back to FreeBSD tree.

This pipe implementation is optional for now, add 'options NEW_PIPE'
to your kernel config to use it.

Import FreeBSD sys/pipe.h rev 1.17 for reference (this was used as a base
for the NetBSD port).

Initial revision