CVS log for src/sys/rump/librump/rumpkern/vm.c

Up to [cvs.NetBSD.org] / src / sys / rump / librump / rumpkern

Request diff between arbitrary revisions

Keyword substitution: kv
Default branch: MAIN

PR kern/57626: instead of an (arbitrary) FAKE_PAGE_SHIFT (and always
using 4k pages), query the hypervisor for the real page size of the host
kernel and use that for architectures that do not have compile time
constant page sizes.

rump: Move ubc_uiomove, ubc_zerorange from rumpvfs to rumpkern.

Needed by kern_ksyms.c.  We could split kern_ksyms.c up into kernel-
internal interfaces and the user/kernel /dev/ksyms interface, but
there's nothing vfs-specific about ubc_uiomove and ubc_zerorange
anyway, so let's just define them in rumpkern.

rumpkern: Provide stub uvm_vnodeops weak alias.

Needed for UVM_OBJ_IS_VNODE, but not for anything else in rumpkern
without rumpvfs.

sys/*: Get module_map consistently from sys/module.h.

rumpkern: Abusing struct pmap internals now requires extra effort.

(as it should)

fix typos in word "successfully", mainly s/succesfully/successfully/.

Pull up following revision(s) - all via patch -
(requested by riastradh in ticket #1317):

	sys/uvm/uvm_page.c: revision 1.248
	sys/uvm/uvm_anon.c: revision 1.80
	sys/rump/librump/rumpvfs/vm_vfs.c: revision 1.40
	sys/rump/librump/rumpvfs/vm_vfs.c: revision 1.41
	sys/rump/librump/rumpkern/vm.c: revision 1.191
	sys/uvm/uvm_pager.c: revision 1.130
	external/cddl/osnet/dist/uts/common/fs/zfs/zfs_vnops.c: revision 1.71
	tests/rump/rumpkern/t_vm.c: revision 1.5
	tests/rump/rumpkern/t_vm.c: revision 1.6
	sys/rump/librump/rumpvfs/vm_vfs.c: revision 1.39

Move the handling of PG_PAGEOUT from uvm_aio_aiodone_pages() to
uvm_page_unbusy() so that all callers of uvm_page_unbusy() don't need to
handle this flag separately.  Split out the pages part of uvm_aio_aiodone()
into uvm_aio_aiodone_pages() in rump just like in the real kernel.

In ZFS functions that can fail to copy data between the ARC and VM pages,
use uvm_aio_aiodone_pages() rather than uvm_page_unbusy() so that we can
handle these "I/O" errors.  Fixes PR 55702.

fix an incorrect assertion in the previous commit.

Handle PG_PAGEOUT in uvm_anon_release() too.

Commit the ZFS file that I forgot in this previous commit:

Move the handling of PG_PAGEOUT from uvm_aio_aiodone_pages() to
uvm_page_unbusy() so that all callers of uvm_page_unbusy() don't need to
handle this flag separately.  Split out the pages part of uvm_aio_aiodone()
into uvm_aio_aiodone_pages() in rump just like in the real kernel.

In ZFS functions that can fail to copy data between the ARC and VM pages,
use uvm_aio_aiodone_pages() rather than uvm_page_unbusy() so that we can
handle these "I/O" errors.  Fixes PR 55702.
update the rump copy of uvm_page_unbusy() to match the real version,
in particular handle PG_PAGEOUT.  fixes a few atf tests.
the busypage test is buggy, expect it to fail.

make rump's uvm_aio_aiodone_pages() look more like the kernel version.
fixes some more rumpy assertions.

for the busypage test, replace atf_tc_expect_fail() with atf_tc_skip()
because atf apparently has no way to expect a test program to crash.
fixes PR 55945.

Sync w/ HEAD.

update the rump copy of uvm_page_unbusy() to match the real version,
in particular handle PG_PAGEOUT.  fixes a few atf tests.

uvm_availmem(): give it a boolean argument to specify whether a recent
cached value will do, or if the very latest total must be fetched.  It can
be called thousands of times a second and fetching the totals impacts not
only the calling LWP but other CPUs doing unrelated activity in the VM
system.

Correction to previous - set VI_PAGES correctly.

PR kern/55032 (rump/rumpkern/t_vm:uvmwait test case now fails)

Work around issues with rump's pagedaemon emulation, including one that's
sensitive to timing effects (i.e. scheduler changes).  While here tidy up
some other stuff around the emulation of page alloc/free.

Merge changes from current as of 20200406

Tweak the March 14th change to make page waits interlocked by pg->interlock.
Remove unneeded changes and only deal with the PQ_WANTED flag, to exclude
possible bugs.

Make page waits (WANTED vs BUSY) interlocked by pg->interlock.  Gets RW
locks out of the equation for sleep/wakeup, and allows observing+waiting
for busy pages when holding only a read lock.  Proposed on tech-kern.

rump - page/object dirtyness tracking corrections.

Sync with head.

UVM locking changes, proposed on tech-kern:

- Change the lock on uvm_object, vm_amap and vm_anon to be a RW lock.
- Break v_interlock and vmobjlock apart.  v_interlock remains a mutex.
- Do partial PV list locking in the x86 pmap.  Others to follow later.

Sync with head.

Merge from yamt-pagecache (after much testing):

- Reduce unnecessary page scan in putpages esp. when an object has a ton of
  pages cached but only a few of them are dirty.

- Reduce the number of pmap operations by tracking page dirtiness more
  precisely in uvm layer.

remove unused predicate function

likely unused since kmem changes

rump: initialize pg->interlock

Fix rump.

Rename uvm_free() -> uvm_availmem().

Rename uvm_page_locked_p() -> uvm_page_owner_locked_p()

Add uvm_free(): returns number of free pages in system.

Merge from yamt-pagecache:

- do gang lookup of pages using radixtree.
- remove now unused uvm_object::uo_memq and vm_page::listq.queue.

Merge from yamt-pagecache: use radixtree for page lookup.

rbtree page lookup was introduced during the NetBSD 5.0 development cycle to
bypass lock contention problems with the (then) global page hash, and was a
temporary solution to allow us to make progress.  radixtree is the intended
replacement.

Ok yamt@.

Break the global uvm_pageqlock into a per-page identity lock and a private
lock for use of the pagedaemon policy code.  Discussed on tech-kern.

PR kern/54209: NetBSD 8 large memory performance extremely low
PR kern/54210: NetBSD-8 processes presumably not exiting
PR kern/54727: writing a large file causes unreasonable system behaviour

update from HEAD

Sync with HEAD

Resolve conflicts from previous merge (all resulting from $NetBSD
keywork expansion)

Add uvm_map_pageable dummy function.  This means that the audio tests
should run again.

Ok christos@.

Sync with HEAD

Provide stupid uvm_map() and uvm_unmap1() immplementations - might be enough
to get audio tests in rump going again.
XXX needs a RUMP chef to review/replace by something sane!

Add a dummy (non-working) uvm_map().
XXX someone with a clue please fix this for real!

Sync with HEAD

Sync with HEAD

add uvm_km_protect()

Sync with HEAD

Put the kernelside rump kernel headers into <rump-sys> instead of
sprinkling them around the faction directories.  Avoids having
to add a CPPFLAGS (or several) to pretty much every component
Makefile.

Leave compat headers around in the old locations.

The commit changes some autogenerated files, but I'll fix the
generators shortly and regen.

Sync with HEAD (as of 26th Dec)

Adapt to e_default_mapaddr signature changes

Sync with HEAD

In case pagedaemon can't release any more memory, use kpause() instead
of cv_timedwait() on the pagedaemon condvar -- it's no use constantly
waking the pagedaemon up for new memory allocation attempts, as will
happen e.g. if new network connections are constantly pouring in.

Give remote clients struct pmap storage.  Although the pmap is unused,
that way we can sure that the pmap macro framework doesn't access all
the wrong places.

g/c rump_vmmap

No recollection what it was used for; didn't seem to be used even when
it was originally added 5th August 2007.

Give the kernel/local pmaps actual storage.

That way friendly neighborhood macros won't go scribbling
in the wrong places.

Sync with HEAD

Use RUMP_PMAP_KERNEL and RUMP_PMAP_LOCAL to denote
kernel and local client pmaps, respectively.

Use a different vmspace for rump kernel proc0 and local clients.
While the rump kernel and local clients are by definition in the same
host vmspace, there are subtle differences in how in-kernel code works
in case accessing the kernel vmspace or a user process vmspace.

Problem discovered by riastradh's "read(fd, NULL, 1)" test.

Put all sysproxy routines to their own C module, sysproxy.c

Pull up following revision(s) (requested by chs in ticket #363):
	common/lib/libprop/prop_kern.c: revision 1.18
	sys/arch/mac68k/dev/grf_compat.c: revision 1.27
	sys/arch/x68k/dev/grf.c: revision 1.45
	sys/external/bsd/drm/dist/bsd-core/drm_bufs.c: revision 1.12
	sys/external/bsd/drm2/drm/drm_drv.c: revision 1.12
	sys/external/bsd/drm2/drm/drm_vm.c: revision 1.6
	sys/external/bsd/drm2/include/linux/mm.h: revision 1.4
	sys/kern/vfs_vnops.c: revision 1.192 via patch
	sys/rump/librump/rumpkern/vm.c: revision 1.160
	sys/sys/file.h: revision 1.78 via patch
	sys/uvm/uvm_device.c: revision 1.64
	sys/uvm/uvm_device.h: revision 1.13
	sys/uvm/uvm_extern.h: revision 1.192
	sys/uvm/uvm_mmap.c: revision 1.150 via patch
add a new "fo_mmap" fileops method to allow use of arbitrary uvm_objects for
mappings of file objects.  move vnode-specific details of mmap()ing a vnode
from uvm_mmap() to the new vnode-specific vn_mmap().  add new uvm_mmap_dev()
and uvm_mmap_anon() convenience functions for mapping character devices
and anonymous memory, and replace all other calls to uvm_mmap() with those.
use the new fileop in drm2 so that libdrm can use mmap() to map things
like on other platforms (instead of the ioctl that we have used so far).

add a new "fo_mmap" fileops method to allow use of arbitrary uvm_objects for
mappings of file objects.  move vnode-specific details of mmap()ing a vnode
from uvm_mmap() to the new vnode-specific vn_mmap().  add new uvm_mmap_dev()
and uvm_mmap_anon() convenience functions for mapping character devices
and anonymous memory, and replace all other calls to uvm_mmap() with those.
use the new fileop in drm2 so that libdrm can use mmap() to map things
like on other platforms (instead of the ioctl that we have used so far).

Rebase to HEAD as of a few days ago.

Rebase.

update comment

make sure we don't underflow the memlimit

fill in a few more uvmexp entries

sync with head.

for a reference, the tree before this commit was tagged
as yamt-pagecache-tag8.

this commit was splitted into small chunks to avoid
a limitation of cvs.  ("Protocol error: too many arguments")

sync with head

Init function pointers to nullop() so that callers don't need a dance

apparently DFLSSIZ isn't defined on powerpc, so pull a value out of el stetson

Pretend that we have slightly more reasonable stack size limits.
(we don't have stacks, that's why we pretend)

implement lwp_create() and a few related interfaces.
main raison d'impalerment: the aio driver

kill undesirable #ifndef _RUMPKERNEL

deduplicate uvm_object_printit() implementation

Fix the memory limiter to work for non-pagedaemon threads again

reported by njoly

Use same uvm_swap_shutdown() stub for !vmswap kernels and rump kernels.

simply issue a warning if <1MB RAM configured.  it might work, but
not going to start enumerating when and where it might.

reserve a small amount of memory for the pagedaemon

Adapt to new uvm_estimatepageable arguments

add a copy of uvm_swap_shutdown() here so that it is not undefined when we
use it.

As discussed on tech-kern: make TOPDOWN-VM runtime selectable per process
(offer MD code or emulations to override it).

resync from head

Flip parameter order in the clock hypercalls to make them consistent
with everything else wrt in/out parameters.

add missing demogorgon

Make hypercall calling conventions consistent: iff a hypercall can fail,
it returns an int containing the error value.

Replace the various "get info from hypervisor" interfaces with one
unified rumpuser_getparam(), and make it return a plist.  The
contents can come e.g. from the env or a config file.  Make
identifiers starting with an underscore denote system identifiers
which must be implemented by hypervisor. (yea, j/k about the plist bit)

Appearances count: spell "IPL_NONE" correctly.

Improve the time-related hypercalls so that's it's possible to
sleep until an absolute time on the host's monotonic clock (should
something like that be supported).

* treat kern_malloc.c as an unreal allocator (it's so lightweight)
* get rid of the rumpuser_realloc() hypercall
* pass size to rumpuser_free()

Use kern_malloc.c instead of the relegated allocators in memalloc.c.
Previously this didn't make sense due to the use of kmem_map, but the
new malloc is more dynamic and puts sense into using it.

simplify code
add a comment

resync with head

make vmem(9) ready to be used early during bootstrap to replace extent(9)
pass memory for vmem structs into the initialization function and
do away with the static pool of vmem structs.
remove special bootstrapping of the quantum cache pools of the kmem_va_arena
as memory for pool_caches is allocated via pool_allocator_meta which is
fully operational at this point.

revert previous commit not yet fully functional, sorry

make vmem(9) ready to be used early during bootstrap to replace extent(9).
pass memory for vmem structs into the initialization functions and
do away with the static pools for this.
factor out the vmem internal structures into a private header.
remove special bootstrapping of the kmem_va_arena as all necessary memory
comes from pool_allocator_meta wich is fully operational at this point.

sync with head

sync with (a bit old) head

Don't use __weak_alias where the component framework is sufficient.

Resync to 2012-11-19 00:00:00 UTC

kill some -Wunused-but-set-variable warnings

fix a merge botch

sync with head

Use mmap hypercall for memory allocation only when absolutely necessary
(map == module_map).  Otherwise, use the malloc hypercall.  This avoids
relying on the platform's mmap() to be able to return arbitrarily
alignment memory.

Make it possible to select between real and unreal allocators from
make.  Plus some gratuitous renaming.

make unreal allocators work again

Now that pool_cache_invalidate() is synchronous and can handle per-CPU
caches, merge together pool_drain_start() and pool_drain_end() into

bool pool_drain(struct pool **ppp);

"bool" value indicates whether reclaiming was fully done (true) or not (false)
"ppp" will contain a pointer to the pool that was drained (optional).

See http://mail-index.netbsd.org/tech-kern/2012/06/04/msg013287.html

sync to latest -current.

Recently uvm_page_locked_p() leaked outside of uvm/MD code, so rump
needs to provide one.

sync with head

sync to latest -current.

Pull up following revision(s) (requested by para in ticket #155):
	sys/kern/subr_vmem.c: revision 1.73
	sys/kern/subr_kmem.c: revision 1.43
	sys/rump/librump/rumpkern/vm.c: revision 1.124
make accounting for vm_inuse sane
while here don't statically allocated for more caches then required
adjust rump for static pool_cache count
should have went in with subr_vmem 1.73
don't overallocated once we leave the caches

Pull up following revision(s) (requested by hannken in ticket #141):
	tests/rump/rumpkern/t_vm.c: revision 1.3
	sys/rump/librump/rumpkern/vm.c: revision 1.125
Don't take a mutex we already took 6 lines above.
Starting with Rev. 1.191 of kern/subr_pool.c a pool has to be inactive
for at least 10 seconds before it can be reclaimed.
Change the uvmwait test timeout from 10 to 30 seconds so it has a chance
to reclaim memory and succeed.

Don't take a mutex we already took 6 lines above.

sync to -current

adjust rump for static pool_cache count
should have went in with subr_vmem 1.73

sync to -current.

Adapt to constification in sys/uvm/uvm_export.h

merge to -current.

uvm_pageout_done doesn't return anything more (it's void).

Update uvm_pageout_done defintion.

Move pool subsystem init from rump__init() to uvm_init(), following
kernel code. Fix RUMP_LOCKDEBUG early panic.

extending vmem(9) to be able to allocated resources for it's own needs.
simplifying uvm_map handling (no special kernel entries anymore no relocking)
make malloc(9) a thin wrapper around kmem(9)
(with private interface for interrupt safety reasons)

releng@ acknowledged

uvm_loanabj: take an access pattern hint.

implement a rump stub of uvm_loanobj

remove uobj->memq

page cache related changes

- maintain object pages in radix tree rather than rb tree.
- reduce unnecessary page scan in putpages.  esp. when an object has a ton of
  pages cached but only a few of them are dirty.
- reduce the number of pmap operations by tracking page dirtiness more
  precisely in uvm layer.
- fix nfs commit range tracking.
- fix nfs write clustering.  XXX hack

replace a non us-ascii character in a comment

trylockowner is not needed anymore.

fix the build for rumpserver.

Catchup with rmind-uvmplock merge.

Make ubc_purge() a noop.

include uvm_object.c in the rump kernel for the new uvm_obj* functions.
don't build the uvm_object.c uvm_object_printit() for _RUMPKERNEL. (XXX)
add empty panic() stubs for uvm_loanbreak() and ubc_purge().

fixes some more 5.99.53 rump build issues.

Welcome to 5.99.53!  Merge rmind-uvmplock branch:

- Reorganize locking in UVM and provide extra serialisation for pmap(9).
  New lock order: [vmpage-owner-lock] -> pmap-lock.

- Simplify locking in some pmap(9) modules by removing P->V locking.

- Use lock object on vmobjlock (and thus vnode_t::v_interlock) to share
  the locks amongst UVM objects where necessary (tmpfs, layerfs, unionfs).

- Rewrite and optimise x86 TLB shootdown code, make it simpler and cleaner.
  Add TLBSTATS option for x86 to collect statistics about TLB shootdowns.

- Unify /dev/mem et al in MI code and provide required locking (removes
  kernel-lock on some ports).  Also, avoid cache-aliasing issues.

Thanks to Andrew Doran and Joerg Sonnenberger, as their initial patches
formed the core changes of this branch.

Sync RUMP's uvm_pagealloc_strat() and processpage() with branch changes.

Sync with HEAD.

sync with head

Update copyright statements.

no functional change.

sync with head

Sync with HEAD

Shuffle the pagedaemon algorithm a bit to record the number of
pageouts active and give up only if the pagedaemon could not free
memory and there are no outstanding pageouts.

This should fix the "out of memory" pauses reported by Mihai Chelaru
and Taylor R Campbell.  Tested by copying files to and from an ffs
backed by /dev/wd0 (with and without -o log) using a 1MB rump kernel
memory limit.

complete the incomplete pagesize rototill

Sync with HEAD

Make vmapbuf() return success/error and make physio deal with a
failure.

Set b_error in vunmapbuf() if copyout_proc fails.
XXX: what if copyin fails in vmapbuf()?

Sync with HEAD

Use correct strtoululululu variant.

from Taylor R Campbell

Add a comment explaning why uvm_reclaim_hook is not currently
necessary for rump.

XXX: strictly speaking, the zfs implementation does not work
correctly since it just wakes up a thread instead of performing
the scan in the context of the pagedaemon

Add support for compiling ZFS and Solaris modules as RUMP libraries. Add
some locking and rumpcopy primitives and refactor module building Makefiles
to work with both RUMP and kernel modules. This is first part of adding
support for regular test of zfs on NetBSD to hunt some bugs and make it
stable.

Ok by pooka@.

Introduce RUMP_LOCALPROC_P() macro and use it.

Do a minidehumanizenumber for RUMP_MEMLIMIT.  Now you can set it
to e.g. 16m instead of having to type out 16777216.

If the pagedaemon cannot free any memory due to not being able to
lock any uvm objects, check if lockholders are currently on CPU
and yield to try very soon again instead of assuming deadlock.

This makes limited-memory kernels perform the same as memory-unlimited
kernels (provided there is a reasonable amount of memory available).
For example, for large file copy off of ffs where the image is
backed on host memory (i.e. no disk i/o, i.e. ideal conditions)
the figures are, per rump kernel memory limit:

3000kB: same
1000kB: 10% slower
500kB:  50% slower

(per pagedaemon code might still be able to use some tweak, though)

Make uvm_pagealloc_tele() fail if the request can't be immediately
satisfied.  This allows the caller to unlock the object and the
pagedaemon to avoid deadlock even if ~all memory is consumed by
one vm object.  This in turn makes is possible to copy a large file
into a rump kernel with a 10MB memory limit (where large >> 10MB).
A little more tuning will be required to avoid the pagedaemon
hitting the sleep-and-retry path, though.

+ fix some outdated unrelated comments

Support physio for remote processes.
==> add support for remote vmspace vmapbuf/vunmapbuf
  ==> add proper support for copyin/out_vmspace
    ==> add support for remote vmspace uvm_io
      ==> add support for non-curproc rumpuser_sp_copyin/out
        ==> store remote context in vm_map->pmap instead of
            pthread_specificdata

In short, makes read/write of most (all?) block devices work from
a remote rump client via rump syscalls.

cleanup some old garbage

Define uvmexp_pagemask and friends used by sparc to set PAGE_SIZE,
PAGE_MASK, PAGE_SHIFT dynamically.

Abstraction fix; move physical address -> per-page metadata (struct
vm_page *) "reverse" lookup code from uvm_page.h to uvm_page.c, to
help migration to not do that.

Likewise move per-page metadata (struct vm_page *) -> physical
address "forward" conversion code into *.c too.  This is called
only low-layer VM and MD code.

Sync with HEAD.

Start rework of system call proxying over socket ("sysproxy").
This incarnation is written in the user namespace as opposed to
the previous one which was done in kernel namespace.  Also, rump
does all the handshaking now instead of excepting an application
to come up with the user namespace socket.

There's still a lot to do, including making code "a bit" more
robust, actually running different clients in a different process
inside the kernel and splitting the client side library from librump.
I'm committing this now so that I don't lose it, plus it generally
works as long as you don't use it in unexcepted ways: i've tested
ifconfig(8), route(8), envstat(8) and sysctl(8).

Sync with HEAD (-D20101022).

Don't reorder page on the age queue if the lookup is done by the
pagedaemon.  This mimics normal kernel behaviour where pmap_kentered
mappings are not tracked for references.  Without this change the
vnode pager's clustering could cause one page to be released by
the pagedaemon, and the rest of the pages in the pageout cluster
made unlikely candidates to be released soon.

sync with head

Fixes/improvements to RB-tree implementation:
1. Fix inverted node order, so that negative value from comparison operator
   would represent lower (left) node, and positive - higher (right) node.
2. Add an argument (i.e. "context"), passed to comparison operators.
3. Change rb_tree_insert_node() to return a node - either inserted one or
   already existing one.
4. Amend the interface to manipulate the actual object, instead of the
   rb_node (in a similar way as Patricia-tree interface does).
5. Update all RB-tree users accordingly.

XXX: Perhaps rename rb.h to rbtree.h, since cleaning-up..

1-3 address the PR/43488 by Jeremy Huddleston.

Passes RB-tree regression tests.
Reviewed by: matt@, christos@

* unlock object in "error" branch
* fix typo (not in comment)
* improve indentation tailspin

Assert that object is locked in page unbusy.

Actually, we want to say "no aobjs" instead of "only vnodes" to
make component boundaries go right.

Improve pagedaemon performance:
  * page out vnode objects
  * drain kmem/kernel_map

As long as there is a reasonable memory hardlimit (>600kB or so),
a rump kernel can now survive file system metadata access for an
arbitrary size file system (provided, of course, that the file
system does not use wired kernel memory for metadata ...).

Data handling still needs a little give&take finetuning.  The
general problem is that a single vm object can easily be the owner
of all vm pages in a rump kernel.  now, if a thread wants to allocate
memory while holding that object locked, there's very little the
pagedaemon can do to avoid deadlock.  but I think the problem can
be solved by making an object release a page when it wants to
allocate a page if a) the system is short on memory and b) too many
pages belong to the object.  that still doesn't take care of the
pathological situation where 1000 threads hold an object with 1
page of memory locked and try to allocate more.  but then again,
running 1000 threads with <1MB of memory is an unlikely scenario.
and ultimately, I call upon the fundamental interaction which is
the basis of why any operating works: luck.

Make the Diabolical (Page)Daemon Director drain vfs buffers when
we are short of memory.

There are still some funnies left to iron out.  For example, with
a certain file system / memory size configuration it's still not
possible to create enough files to make the file system run out of
inodes before the kernel runs out of memory.  Also, with some other
configurations disk access slows down gargantually (though i'm sure
there are >0 buffers available).  Anyway, it ~works for now and
it's by no means worse than what it was before.

Improve page allocator performance by using pool_cache for the
structure itself and allocating the backing page directly from the
hypervisor.

* initial write to a large tmpfs file is almost 2x faster
* truncating the file to 0 length after write is over 50% faster
* rewrite of the file is just slightly faster (indicating that
  kmem does a good job with caching, as expected)

Use rb_tree for page lookup instead of list.  Unshockingly, this
makes dealing with large uobjs (files) quite a bit faster.

Use standard uvm aobj pager.  Most of the kernel aobj pager complexity
comes from swap handling, but that is included only with VMSWAP.

Sync with HEAD.

sync with head.

Correct previous.  Skip marker pages in uvm_pagelookup().
Already awake :-)

Remove questionable KASSERT from previous.  hannken can look at
this more closely when he wakes up.  Normally I wouldn't be in such
a huge rush, but due to atf bug #53 the whole test run breaks now.
At least with the KASSERT removed all tests pass again.

Add vm page flag PG_MARKER and use it to tag dummy marker pages
in genfs_do_putpages() and uao_put().
Use 'v_uobj.uo_npages' to check for an empty memq.
Put some assertions where these marker pages may not appear.

Ok: YAMAMOTO Takashi <yamt@netbsd.org>

sync with head

Make it possible to define an upper limit for memory consumed by
the rump kernel by specifying RUMP_MEMLIMIT.  In case allocation
over that limit is attempted, essentially pool reclaim and uvm_wait()
is done.  The default is to allow to allocate as much as the host
will give.

XXX: uvm_km_alloc and malloc(9) do not currently conform.  the
former is easy, the latter requires kern_malloc.c (rump malloc is
currently directly relegated to host malloc).

Use kern_proc.c instead of a collection of stubs.  But what we
really wanted from this commit was the support for proc_specificdata.

TODO: make creating a new process actually use kern_proc and
maybe even add an interface which starts a process with
"any pid you don't like"

On amd64, allocate module_map memory from the lowest 2GB.

Add the ability to specify a preferred address the "map anon memory"
hypercall.

Implement a sort-of pagedaemon: adjust all memory allocators to go
through an in-rumpkernel hypermemory allocator which knows it should
kick the pagedaemon and block in case ``waitok'' memory allocation
fails.

This allows us to recover from some out-of-memory situations.
Realworld'istically speaking (as opposed to whatever "should be"
theory), these OOM situations will happen extremely rarely if ever
when our hypervisor is a regular process.  Speculatively, this
should be useful for other types of hosts.

issues remaining:
 * the hypervisor does not know how to reclaim kernel memory (and
   for the reason I stated above, I'm not sure if it makes sense
   to teach the current implementation about that)
 * vfs memory (buffers, vm object pages etc.) is not reclaimed

rumpvm_init -> uvm_init to get rid of local prototype.
no functional change

Don't pass "canfail" down to rumpuser_malloc -- there's quite little
we can do with that info way down there.  Instead, pass alignment.
Implement rumpuser_malloc() with posix_memalign().

Always use rumpuser_malloc() for allocating both poolpage and
poolpage_cache -- its bootstrap cost is slightly higher than
anonmmap, but it's faster in the long run.

* remove rumpvm_makepage, just use uvm_pagealloc()
* update copyright to reflect reality a little better

sync with head

print vm object refcount

Pick up after people who find build-testing their changes too difficult.

uvm_object_printit() should be wrapped in DEBUGPRINT

Sync with HEAD.

Fix build of rump.

Instead of causing a catastrophic failure when uvm_loanuobjpages()
is called, just pretend it hit a wired page and return EBUSY.  This
should cause callers to use a non-loaning access path instead.

Fixes file read path of stock nfs kernel module (previously it was
easy to just frob the nfsd_use_loan boolean into the other position
by simple value assingment, but now that nfsserver can be autoloaded
at runtime into the rump kernel, that approach is a little more
challenging since the variable isn't available in application
linkage.  yes, things like adding a sysctl for the variable would
work, but now everything works out-of-the-box).

support kern_resource

Change struct uvm_object::vmobjlock to be dynamically allocated with
mutex_obj_alloc().  It allows us to share the locks among UVM objects.

sync with head

g/c unused functions (previously used by the vnode pager).

Implement enough of uvm_mmap() to make the creative proplib ioctl
copyout code work.  No comments ... okok, if that'll make you leave
me alone: it's ioctl, so it's supposed to be funky (with a score
or two of psychedelic rock).

Provide the default_mapaddr method in default rump emul (since some
kernel callers want to use it).

Pull all relegating memory allocators under a common roof in memalloc.c

Use std. uiomove() & friends.

Sync rump with kernel changes.

Remove uarea swap-out functionality:

- Addresses the issue described in PR/38828.
- Some simplification in threading and sleepq subsystems.
- Eliminates pmap_collect() and, as a side note, allows pmap optimisations.
- Eliminates XS_CTL_DATA_ONSTACK in scsipi code.
- Avoids few scans on LWP list and thus potentially long holds of proc_lock.
- Cuts ~1.5k lines of code.  Reduces amd64 kernel size by ~4k.
- Removes __SWAP_BROKEN cases.

Tested on x86, mips, acorn32 (thanks <mpumford>) and partly tested on
acorn26 (thanks to <bjh21>).

Discussed on <tech-kern>, reviewed by <ad>.

remove stale uvm_readahead() stub

Include sys_select.c for proper select()/poll() support.

sync with head.

* support uvm_pagermapin/out(), adapt uvm_pageratop()

  Instead of doing actual page remapping, which we can't portably
  do in userspace without extensive trickery (read: signals), simply
  allocate the kva window with new physical backing, copy page
  contents, return, and copy contents back in mapout.  Since the
  pages are locked during the mapping cycle, we can do this without
  hazard.

* add lots of stubbies necessary for new stuff coming soon

g/c cachepgmtx, i have no idea what it was supposed to be useful for.

track number of pages associated with vm object

Sync with HEAD.

sync with head

Add a dummy uvm_readahead() function, to fix build issues after it
recently got added to the kernel.
OK'ed by pooka@

Add user vmspace locking and remapping routines.  Obviously, these
currently work only if the vmspace is local to the rump kernel.

Sync with HEAD.

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

sync with head.

define DEBUGPRINT

Free uao lock when destroying object.  Fixes tmpfs rename leak
reported by njoly.

Sync with HEAD.

* init pool linksets, makes proplib work.  reported by Arnaud Ysmal.
  (linksets, sigh)
* reduce #ifdef for RUMP_USE_REAL_ALLOCATORS

Ansify function definitions w/o arguments. Generated with sed.

Sync with HEAD.

Call uvm_page_unbusy() instead of manually yanking PG_BUSY out.

last-minute pasto in previous

Add a compile-time option to use kmem/vmem/pools from the kernel
sources instead of homegrown allocators.  Default to "on", even
though they appear to be a few percent slower at least on short
jobs (e.g. untar to tmpfs).

Sync with HEAD.

Sync with HEAD.

Include libkern contents in librump.

__KERNEL_RCSID

Mark pages busy during VOP_PUTPAGES().  Deals with KASSERT in nfs write.

Make rumpflushva flush only the atop info for a certain uvm object.
Better, but still not completely race-free (if two threads call
RUMP_VOP_PUTPAGES() directly for the same vm object).

Update haad-dm branch to haad-dm-base2.

Move more vfs-related vm routines from rumpkern to rumpvfs.

Remove the whole magic ubc window thingie.  All file systems use
ubc_uiomove() now, so we can hook ourselves there.

Add a few symbols required by nfsd

Split vfs out of rumpkern into rumpvfs.  Non-fs rumps no longer
include the file system code.  File system rumps explicitly need
to include rumpvfs from now on.

Sync with HEAD.

Add support bits necessary for rumpnet functionality.

Sync with HEAD.

* implement uvm_km_alloc/free_poolpage()
* add silly stubs for uvm_lwp_hold/rele()

reorganize routines a bit better.  no functional change

Sync with HEAD.

Make sure proc0.p_vmspace qualifies as VMSPACE_IS_KERNEL_P().

Sync with HEAD.

Sync with wrstuden-revivesa-base-2.

pg->flags &= PG_CLEAN --> &= ~PG_CLEAN;

Fixes at least writing to the fs for msdosfs.

Honor PG_RELEASED when unbusying a page.

Fixes ufs file system full problem discovered by Simon Burge.

Add support for using real kmem/vmem.  Don't enable it by default,
though, since it a) is a lot of unnecessary indirection in rump
b) requires callouts which are so far unimplemented.

Sync with head.

Install rump libraries and utilities to the base system and remove the
private non-installed build infrastructure from sys/rump.

breakdown of commit:
  * install relevant headers into /usr/include/rump
  * build sys/rump/librump/rumpuser and sys/rump/librump/rumpkern
    from src/lib and install as librumpuser and librump, respectively
    + this retains the ability to test a librump build with just the
      kernel sources at hand
  * move sys/rump/fs/lib/libukfs and sys/rump/fs/lib/libp2k to src/lib
    for general consumption, they are not kernel-space dwellers anyway
  * build and install sys/rump/fs/lib/lib$fs as librumpfs_$fs
  * add chapter 3 manual pages for rump, rumpuser, ukfs and p2k
  * build and install userspace kernel file system daemons if MKPUFFS=yes
    is spexified
  * retire fsconsole for now, it will make a comeback with an actually
    implemented version shortly

Sync with head.

assert -> KASSERT

Sync w/ -current. 34 merge conflicts to follow.

sync with head.

Sync with HEAD.

Also fix build.

Make it build again.

Make it build.

Sync with HEAD.

sync with head.

sync with HEAD

sync with head.

Backup some fixes for recent breakage from local tree.  Also some
other improvements such as exporting the real kernel namei and
using that in ukfs instead of the homegrown heap'o hacks namei.
"etcetc".

Sync with HEAD.

sync with head.

honor pager locking protocol in uao_detach()

Fix locking botches: take vm object lock before calling pager,
not inside the pager.

sync with head

sync with HEAD

Sync with HEAD

Theoretically this is supposed to be interchangeable with real
kernel code.  Use kmem_alloc/free instead of some wily homerolled
rump interfaces for memory allocation.

Sync with HEAD

fix vmlocking2 fallout:

* I heard a wild rumor that vp_interlock is a mutex these days (hi ad!)
* init new locks (hi ad)
* observe that with simple_locks only deadlocks would be caught while
  releasing unlocked locks would go unnoticed.  make locking work (hi pooka)

Merge vmlocking2 to head.

Make rump build.

Sync with HEAD.

sync with head

Sync with HEAD.

constify pagerops.

Sync with HEAD.

sync with head.

Sync with HEAD

sync with -HEAD

sync with HEAD

Sync with HEAD.

Fix locking issues with the anonymous pager too so that tmpfs can work.

Sprinkle some more locking, especially to the vm.  Due to some
additional fixes, it's now possible to run file systems with
spinlocks actually enabled.  The genfs_putpages() locking is still
working only due to greater powers, but I'll eventually get around to
fixing it.

Sync with HEAD.

* sprinkle some locking into the vm code
* avoid extra insert+search+remove step in file systems using
  ubc_uiomove() instead of standard uiomove()

Remove the rest of the unintentional diff in sys/rump.

Sync with HEAD.

file vm.c was added on branch jmcneill-pm on 2007-10-31 23:14:18 +0000

Make it possible to run rumps multithreaded.  This brings real
locking and makes it possible to run file systems which create
threads.  It also makes rump file system behaviour better match
file system behaviour in the kernel.

In uvm_estimatepageable() "estimate" pageable.

sync with head.

sync with head.

Merge from vmlocking:

- Split vnode::v_flag into three fields, depending on field locking.
- simple_lock -> kmutex in a few places.
- Fix some simple locking problems.

Sync with head.

don't allocate variable-sized arrays from the stack

sync with head.

Sync with HEAD.

file vm.c was added on branch yamt-lazymbuf on 2007-09-03 14:45:38 +0000

Make bioops a pointer and point it to the softdeps struct in softdep
init.  Decouples "options SOFTDEP" from the main kernel and ffs code.

* add a very crude version of uvm_pageatop()
* add biodone/aiodone

few panicky functions

Sync with HEAD.

file vm.c was added on branch vmlocking on 2007-08-20 22:07:31 +0000

Hide NetBSD kernel headers completely from ukfs.  This includes creating
accessors for:
  * struct mount & VFS ops
  * struct uio
  * struct vnode
  * struct vattr

and some namespace games for:
  * namei flags
  * VOPs
  * enum vtype

Also, split rump services into two categories: library private and public
(rump_private.h and rump.h, respectively).

As a result, it is now possible to compile and use the NetBSD kernel
file systems on Linux (and probably other systems too with very
little work), although the makefiles need a bit of work to make it
a pleasureable experience.

Sync with HEAD.

file vm.c was added on branch nick-csl-alignment on 2007-08-15 13:50:43 +0000

Kill handrolled buffercache and use vfs_bio from the kernel.  This is
mostly to get the flag jungle in sync with the kernel.

Use supermarket variety vfs_vnops.c instead of homecooked routines
(that's actually a good thing here).

* move rump_vopwrite_fault() into history - we now support the file
  system faulting in pages if it does e.g. fragment reallocation
* get rid of rumpvm_findpage() and always use uvm_pagelookup()
* determine a vnode's cleanness by flagging it as being on the work
  list if we "take" a write fault and removing it from the worklist
  once pages are flushed.  There is no work list here, but at least
  there is symmetry with the kernel.

Play catchup with ufs/ffs changes: compile subr_specificdata.c
and emulate kmem_foo() to support the prior.

Fix it a bit & wait for the dust to settle.  Also, enable UBC by default.

ffs in userspace on top of puffs/p2k/rump is now stable enough to
host a make -j4 kernel build (well, at least my kernel build ...
but, yes, I am currently running that kernel on my desktop)

Add some stubs for lfs.

remove the allocstorage param from makepage - not needed

track dirty vm objects

When doing "ubc faults", truncate offsets to page boundary to get
the last page also if it's accessed from the middle of the page.

Instead of going for a PAGE_SIZE nuke, do getpages() in a more
sniper style.  Makes efs (& other file systems with bsize < PAGE_SIZE)
work better.

file vm.c was added on branch matt-mips64 on 2007-08-06 20:46:29 +0000

Instead of going for a PAGE_SIZE nuke, do getpages() in a more
sniper style.  Makes efs (& other file systems with bsize < PAGE_SIZE)
work better.

implement uvm_vnp_zerorange()

Introduce RUMPs - Runnable Userspace Meta-Programs

/sys/rump contains programs which run unmodified kernel code in an
emulated userspace environment.  The kernel environment is provided
by librump.  Currently supported are a number of file systems,
which by using puffs integrate seamlessly into the system and
provide a similar user experience to if the code was running as
part of the kernel.  Potential future rumpification targets include
for example parts of the networking stack and some device drivers.

This work was supported by Google Summer of Code 2007.