CVS log for src/sys/rump/include/rump/rumpuser.h

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

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.

Merge changes from current as of 20200406

Teach rump to process __link_set_evcnts entries.  (Second part of
fix for PR kern/55088)

Pull up following revision(s) (requested by ozaki-r in ticket #495):
	lib/librumpuser/rumpfiber.c: revision 1.13
	lib/librumpuser/rumpuser_pth.c: revision 1.46
	lib/librumpuser/rumpuser_pth_dummy.c: revision 1.18
	sys/kern/kern_condvar.c: revision 1.40
	sys/kern/kern_lock.c: revision 1.161
	sys/kern/kern_mutex.c: revision 1.68
	sys/kern/kern_rwlock.c: revision 1.48
	sys/rump/include/rump/rumpuser.h: revision 1.115
	sys/rump/librump/rumpkern/locks.c: revision 1.76-1.79
Apply C99-style struct initialization to lockops_t
--
Tweak LOCKDEBUG macros (NFC)
--
Distinguish spin mutex and adaptive mutex on rump kernels for LOCKDEBUG
Formerly rump kernels treated the two types of mutexes as both adaptive for
LOCKDEBUG for some reasons.
Now we can detect violations of mutex restrictions on rump kernels such as
taking an adaptive mutex with holding a spin mutex as well as normal kernels.
--
rump: check if the mutex is surely owned by the caller in mutex_exit
Unlocking a not-owned mutex wasn't detected well (it could detect if the mutex
is not held by anyone but that's not enough). Let's check it (the check is the
same as normal kernel's mutex).
If LOCKDEBUG is enabled, give the check over LOCKDEBUG because it can provide
better debugging information.

Distinguish spin mutex and adaptive mutex on rump kernels for LOCKDEBUG

Formerly rump kernels treated the two types of mutexes as both adaptive for
LOCKDEBUG for some reasons.

Now we can detect violations of mutex restrictions on rump kernels such as
taking an adaptive mutex with holding a spin mutex as well as normal kernels.

update from HEAD

Sync with HEAD

limit visibility of sysproxy calls to where they are needed

Rebase to HEAD as of a few days ago.

Rebase.

Revert last change. This is not the right place for rumpuser_sync_icache().

Implement rumpuser_sync_icache hypercall.

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

weak alias removal implication: rumpuser_dl_globalsym() can now sleep
with the fishes.

remove unnecesary verbosity: s/RUMP_CURLWP_MODEL/RUMP_CURLWP/

Allow compile-time optimizations to curlwp.  This can have a pretty
staggering impact on performance.  When running sendto() in a loop,
the improvement is 200k more calls per second with an inlined __thread
curlwp as opposed to the default.  In other words, it shaves off hundreds
of CPU cycles per call (~20%).  Even just eliminating the x86_curlwp()
call in favor of an inline gives an improvement of 60k calls per second.

resync from head

Looks like I'm done revamping, so bump interface version to 17,
where it will hopefully stay for all eternity (unless some snafus
are discovered before NetBSD 7).

Add a generalized rumpuser_syncfd() call which allows the caller
to request a sync or a barrier for fd.

Pass off_t over the hypercall interface as int64_t to avoid potential
problems in setups where off_t doesn't want to be 64bit.

I'm already excitedly waiting for 128bit off_t and _LARGE_LARGE_FILES

Pass enums over the hypercall interface as ints to avoid some
pathological scenarios from arising in setups where enums might be
of a different size in the rump kernel and hypervisor.

Add RUMPUSER_LWP_CLEAR instead of overloading RUMPUSER_LWP_SET.
This simplifies some alternative hypervisor implementations.

Ok, maybe using int64 for nanoseconds in the (sec,nsec) tuple was
a bit too future-proof.  I think long is enough there (let's just
hope nobody redefines "nano").  Also, make seconds signed just in
case someone wants their clock to be in 1901.

Push rwlock upgrade and downgrade into the hypervisor where there's
at least a chance to implement them with minimal fuss.

Inform the rump kernel hypervisor of valid thread contexts so
that the implementation can allocate and release storage for them
in an optimal fashion, if necessary.

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

In kthread_create(), pass the priority and cpu index down to the
rump kernel hypervisor (though the current implementation doesn't take
advantage of them).

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

Reduce hypercalls related to reading to essentially an amalgamation
of readv and preadv.  ditto for writing.  Hypercalls are so seldomly
used that it doesn't justify 3x the calls for syntactic sugar.

remove accidentally committed bit

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)

The fsync hypercall is now used only with close, so get rid of it.
rumpuser_bio() should do the necessary syncing.

Make the rump kernel upcalls which were previous available only to
the sysproxy module available for the entire hypervisor.

regroup calls a bit and sprinkle comments
no functional change for a change

RUMPUSER_OPEN_DIRECT is no longer necessary

changes to bio hypercalls, part 3/n:

retire the filemmap/memsync hypercalls, they're no longer used

Rework how the bio hypercalls work, part 1/n:

Reduce the set of hypercalls to one: "do block i/o".  This not only
eliminates a lot of pseudo-duplicate code, it also gives the
hypervisor a lot more freedom on how to optimize the i/o.

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).

make the file monitoring hypercalls private to shmif

The ioctl hypercall is used only by the usb host controller driver,
so make it exclusive to that component.  I'm happy to see it gone.

make the random hypercall more generic

roll mutex init hypercalls into one (one of them already took a flag anyway)

move struct lwp forward decl before its first use.  otherwise it's rather
pointless.  some whitespace landscaping too.

wrap unportable register_t with a long.  should do it in the front
of the house too, but at least this is a start.

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

Let the includer figure out where to get stdint or equivalent from.

rumpuser_poll() is used only by sockin, so make the hypercall
private to that component.

* integrate rumpuser_getversion() with the hypervisor initialization
* rename some identifiers to better match reality

remove prototypes for interfaces no longer provided

Try to make sure that the appropriate calls to mutex_enter() takes
a spin mutex (i.e. does not relinquish cpu context while trying to
take the mutex).

Bump the hypercall interface version number.  I'll be doing a bunch
of other cleanups to simplify the interface for the benefit of
alternative hypervisor implementations.  I'll be riding this bump
and doing a second one only after I'm finished with all of the
changes.

Ensure that rump kernel component constructors from the main object
get processed.  This applies to ones which were linked statically.
Unfortunately, that's where it got a bit tricky, since the dlsym()
interface searches the handle and all its dependencies.  For the main
object the list of dependencies includes all the dynamic rump kernel
components that were included when the binary is linked.  So, a long
story short, make only one pass through the objects to harvest all the
component entries, weed out the dupes, and initialize components from
an in-memory dupe-free list when so requested.

limit use of rumpuser.h to where it is meant to be used from

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

sync with head

Do not assume that O_FOO flags have matching values in the rump kernel
and hypervisor.

sync with head

sync to latest -current.

Add __printflike attribution to use vprintf and friends with an argument
as format string.

Remove arc4random() and arc4randbytes() from the kernel API.  Replace
arc4random() hacks in rump with stubs that call the host arc4random() to
get numbers that are hopefully actually random (arc4random() keyed with
stack junk is not).  This should fix some of the currently failing anita
tests -- we should no longer generate duplicate "random" MAC addresses in
the test environment.

Use __dead

Sync with HEAD.

sync with head

Mark rumpuser_exit and rumpuser_thread_exit as dead.

sync with head

Update copyright statements.

no functional change.

Nuke all threads belonging to a process calling exec before allowing
the exec handshake to return.

In addition to being The Right Thing To Do, fixes some nasty
conditions for CLOEXEC fd's (or at least does so in theory, I
couldn't create any problems although I tried).

sync with head

Sync with HEAD

Add an "exec" callback for the proxy code.  The client can now
notify the rump kernel of an exec having taken place.

Sync with HEAD

Pass the value of getprogname() from the client to the server and
record it in p_comm.  This is nice for things like sockstat, since
they now display the client command name:

pain-rustique:43:~> rump.sockstat
USER     COMMAND    PID   FD PROTO  LOCAL ADDRESS         FOREIGN ADDRESS
root     xulrunner- 16     0 tcp    192.168.2.114.65507   204.152.190.12.80
root     xulrunner- 16     1 tcp    192.168.2.114.65501   204.152.190.12.80
root     xulrunner- 16     2 tcp    192.168.2.114.65500   204.152.190.12.80
root     xulrunner- 16     3 tcp    192.168.2.114.65499   204.152.190.12.80
root     xulrunner- 16     5 tcp    192.168.2.114.65498   204.152.190.12.80
root     xulrunner- 16     6 tcp    192.168.2.114.65497   204.152.190.12.80
root     socket     62     0 tcp6   *.http                *.*
root     socket     62     1 tcp    *.http                *.*
root     socket     63     0 tcp6   *.81                  *.*
root     socket     63     1 tcp    *.81                  *.*

In case sys_reboot() was called by a remote client, put the response
in the socket before we shut down.  This way the response to the
syscall travels to the caller and they know things worked correctly
instead of having to just assume.

Support SIGMODEL_RAISE for non-local clients.

add spop_procexit

There is a use case where preserving the parent's fd table is
relevant, so to accommodate that change rump_lwproc_newproc() to
rump_lwproc_rfork().  The new interface has the rfork() fd table
semantics.  The equivalent of rump_lwproc_newproc() is
rump_lwproc_rfork(RUMP_RFCFDG).

Allow rump kernel to call dlsym(RTLD_DEFAULT).

Print a banner a connecting client.  The banner contains rump sp
protocol version, os name, os revision and machine.

add rumpuser_sp_fini, which surpringly is the opposite of rumpuser_sp_init

implement mutex_owner()

rumpuser interface changed

Track lwp as the rumpuser mutex owner instead of pthread_t (this
is done in rumpuser for simplicity, since on the kernel side things
we assume we have only one pointer of space).  As a side-effect,
we can no longer know if the current thread is holding on to a
mutex locked without curlwp context (basically all mutexes inited
outside of mutex_init()).  The only thing that called rumpuser_mutex_held()
for a non-kmutex was the giant lock.  So, instead implement recursive
locking for the giant lock in the rump kernel and get rid of the
now-unused recursive pthread mutex in the hypercall interface.

Require server to be explicitly initialized with rump_init_server(url).
Also, add rump_daemonize_begin() / rump_daemonize_end() to help
with the "can't daemon() after pthread_create()" problem.  Applications
could accomplish the same, but since it's such a common operation,
provide a little help.

*facepalm*, adjust remote copyinstr to work in cases where the end
of the max copyin extends to an unmapped page.

Noticed, as usual, by tests.

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.

Pass routines necessary for multithreaded operation down to rumpuser_sp.

Sync with HEAD.

bump rumpuser version

Refactor the sysproxy code so that rumpuser contains only the server side.

Missed a few symbols in previous ...

Also, reorganize rumpuser header inclusion to make sure problem is
caught already by the compiler.

Make librumpuser linkage once again free of librump.

problem pointed out by <he>

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.

sync with head.

sync with head

Version rumpuser ABI with a lightweight mechanism.

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

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().

Support KTHREAD_JOINABLE/kthread_join().  Also fixes earlier bug
where all pthreads were created non-detached.

sync with head

Make it possible to use the scheduler lock as the rumpuser condvar
interlock.  This is applicable in cases where the actual interlock
is the CPU the currently running thread is scheduled on.  Borrowing
the scheduler lock as the mutex mandated by pthread_cond_wait()
does away with need to have an additional mutex.  This both optimizes
runtime execution and simplifies code, as the extra lock typically
lead to quite some trickeries to avoid the dungeon collapsing due
to zaps from the wand of deadlock.

Sync with HEAD.

Add rumpuser interface to fetch number of host cpus.

Add rumpuser_kill, which sends a signal to a host process.

sync with head

During bootstrap, process all modinfos in a DSO in one go.  Get
rid of dependency tricks, since they are no longer necessary.

Introduce RUMP_COMPONENT.  It behaves mostly like a simplified
module which is linked into the kernel and cannot be unloaded.
The main purpose is to get the proper constructors run and create
any /dev nodes necessary for said component.  Once more of the
kernel (e.g. networking stack and device drivers) are converted to
MODULE and devfs pops up from somewhere, rump components can be
retired.

Rename rumpuser_dl_module_bootstrap() to rumpuser_dl_bootstrap(),
since it hasn't been involved only with modules for quite a while now.

Fixed ukfs build on non-NetBSD system.

Build the kernel symbol table in rumpuser bootstrap and feed it to
the rump kernel.  After this change it is possible to use the
in-kernel linker and rump_sys_modctl() to load kernel modules at
runtime.

Previously loading modules at runtime was possible only through
using the host system ld.so.  Note that it is still preferred to
use shared libs when possible, since they are PIC and n virtual
kernels will only require one copy of r/o segments.  However, when
there is no access to source code, a binary kernel module is the
only thing available ...

Create async i/o "interrupt" thread from within the kernel so that
it gets a kernel thread context.

Make rumpuser_cv_timedwait take two int64's instead timespec to
uncouple it from the timespec layout.  Also, change return value
to zero for "timeout didn't expire" and non-zero for "timeout
expired".  This decouples the interface from errno assignments.

Pass modinit to rumpuser_dl_module_bootstrap() as a function pointer
to avoid linker rump -> rumpuser -> rump dependency which is annoying
redundancy in static linking.

unused rumpuser_realpath is really dead

Add prototype for wait operation variants which do not drop any
resources (because they should be holding any in the first place).

Provide an interface for reboot.

Load modules from all components which are linked into a rump binary
with -lrumpcomponent.  Previously only the first library component
containing a module would get loaded automatically.

<sys/stdint.h> is a non-standard header, so include it only from
kernel code (where it will be included from the NetBSD kernel source
tree).  Use <stdint.h> in userland namespace, i.e. when compiling
librumpuser.

sync with head

add rumpuser_net_setsockopt()

Sync with HEAD.

sync with head

Add rumpuser_dprintf(), which can be used as a "safe" debug print
routine -- the kernel printf does a lot of crud which is not always
nice and dandy especially when debugging locks.

Sync with HEAD.

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

sync with head.

Sync with HEAD.

file rumpuser.h was added on branch yamt-nfs-mp on 2009-05-04 08:14:29 +0000

* expand syncing logic into rumpuser, since it has more freedom on
  how to do it (e.g. fsync_range)
* hash out O_DIRECT support.  it's the fastest method of safely operating
  on a file, but we can't currently autodetect support, so it's not
  enabled by default
* sprinkle more event counters

Bump maximum number of outstanding async i/o's to 1024, 128 can
fill up really fast.

Make it possible to use VCHR devices again.

* allow to specify PROT_READ/PROT_WRITE when mmapping a file
* add msync

Sync with HEAD.

Remember to commit the rumpuser bits necessary for if_shm: mmaping
a file and waiting for writes to it.

decouple rumpuser gettime from struct timeval

decouple from host struct iovec

Make rumpuser stat and nanosleep independent of the host system
stat and timespec definitions.

Make the clock interrupt tick based on absolute time instead of
relative time.  This prevents drifting.  Also, keep track of time
within userspace, so we do not have to make a syscall to get the
clock value.  This is approximately 7 times cheaper, but on the
negative side is limited to the clock interrupt frequency.

Rip out the rwlock spl emulation code.  It never did anything useful
except keep my feet warm by consuming an insane amount of cpu
cycles -- in rump our current "cpu" context is never interrupted
& we have MULTIPROCESSOR.

(itch i'm scratching: it made the networking stack 10-20% slower.
this is one of the places where fast code actually matters)

Instead of dynamically allocating and freeing the rumpuser async
io descriptors, just allocate an array statically and be happy.

Fixes a problem found by Arnaud Ysmal where a descriptor would be
allocated using kmem_alloc(9) and free'd using free(3).

Support getsockname() and getpeername() in rumpuser.

XXX: all these rumpuser_net routines passing sockaddr should use proplib.

rumpuser_seterrno() to set errno from a rump kernel context.

Support mmapping anonymous memory.
XXX: this is mainly for the benefit of correct alignment, but
MAP_ALIGNED() is not portable.

Sync with HEAD.

Sync with HEAD.

file rumpuser.h was added on branch nick-hppapmap on 2009-01-19 13:20:25 +0000

file rumpuser.h was added on branch mjf-devfs2 on 2009-01-17 13:29:35 +0000

missed this in previous commit:

Explicitly pass a pointer to the kernel lock/unlock routines in
rumpuser init instead of magically relying on the linker giving us
the symbols.

thanks to uwe for pointing out

more namespacing: rua -> rumpuser_aio

Rename _rumpuser_malloc to rumpuser__malloc so that all exported
rumpuser symbols start with "rumpuser".
(no major bumps or compat will be provided)

g/c unused rumpuser bswap routines

Include kernel printf routines in rump instead of relying on the
magic libc symbol.  This also allows to bid farewell to subr_prf2.c
and merge the contents back to subr_prf.c.  The host kernel bridging
is now done via rumpuser_putchar().

If available (__NetBSD__), use pthread_setname_np() to set the
thread name for kthread_create().

Support PRU_BIND / PRU_LISTEN / PRU_ACCEPT in sockin.

Pass biodone() to rumpuser as a callback instead of hardcoding it.
Also, explicitly init rumpuser async io thread.

Move rump public headers to include/rump