Home Man
Today's Posts

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:
Select Section of Man Page:
Select Man Page Repository:

NetBSD 6.1.5 - man page for rump_lwproc (netbsd section 3)

RUMP_LWPROC(3)			   BSD Library Functions Manual 		   RUMP_LWPROC(3)

     rump_lwproc -- rump process/lwp management

     rump kernel (librump, -lrump)

     #include <rump/rump.h>

     rump_pub_lwproc_rfork(int flags);

     rump_pub_lwproc_newlwp(pid_t pid);

     rump_pub_lwproc_switch(struct lwp *l);


     struct lwp *

     In a normal operating system model a process is a resource container and a thread (lwp) is
     the execution context.  Every lwp is associated with exactly one process, and a process is
     associated with one or more lwps.	The current lwp (curlwp) indicates the current process
     and determines which resources, such as UID/GID, current working directory, and file
     descriptor table, are currently used.  These basic principles apply to rump kernels as well,
     but since rump uses the host's thread and process context directly, the rules for how thread
     context is determined are different.

     In the rump model, each host thread (pthread) is either bound to a rump kernel lwp or
     accesses the rump kernel with an implicit thread context associated with pid 1.  An implicit
     thread context is created every time the rump kernel is entered and disbanded upon exit.
     While convenient for occasional calls, creating an implicit thread uses a shared resource
     which can become highly contended in a multithreaded situation.  It is therefore recommended
     that dedicated threads are created.

     The association between host threads and the rump kernel curlwp is left to the caller.  It
     is possible to create a dedicated host thread for every rump kernel lwp or multiplex them on
     top of a single host thread.  After rump lwps have been created, switching curlwp is very
     cheap -- faster than a thread context switch on the host.	In case multiple lwps/processes
     are created, it is the caller's responsibility to keep track of them and release them when
     they are no longer necessary.  Like other rump kernel resources, procs/lwps will be released
     when the process hosting the rump kernel exits.

	   Create a process, one lwp inside it and set curlwp to the new lwp.  The flags parame-
	   ter controls how file descriptors are inherited from the parent.  By default (flags=0)
	   file descriptors are shared.  Other options are:

	   RUMP_RFFDG	  Copy file descriptors from parent.  This is what fork(2) does.

	   RUMP_RFCFDG	  File descriptors neither copied nor shared, i.e. new process does not
			  have access to the parent's file descriptors.

	   This routine returns 0 for success or an errno indicating the reason for failure.  The
	   new process id can be retrieved in the normal fashion by calling rump_sys_getpid().

	   Create a new lwp attached to the process specified by pid.  Sets curlwp to the new
	   lwp.  This routine returns 0 for success or an errno indicating the reason for fail-

	   Sets curlwp to l.  In case the new thread is associated with a different process than
	   the current one, the process context is also switched.  The special value NULL sets
	   curlwp to implicit context.	Switching to an already running lwp, i.e. attempting to
	   use the same curlwp in two host threads simultaneously causes a fatal error.

	   Release curlwp and set curlwp to context.  In case curlwp was the last thread inside
	   the current process, the process container is also released.  Calling this routine
	   without a dedicated curlwp is a fatal error.

	   Returns curlwp or NULL if the current context is an implicit context.

     getpid(2), rump(3)

     rump_lwproc first appeared in NetBSD 6.0.

BSD					 January 2, 2011				      BSD

All times are GMT -4. The time now is 06:48 AM.

Unix & Linux Forums Content Copyrightę1993-2018. All Rights Reserved.
Show Password

Not a Forum Member?
Forgot Password?