rump_etfs(3) [netbsd man page]

RUMP_ETFS(3)						   BSD Library Functions Manual 					      RUMP_ETFS(3)

NAME

     rump_etfs -- rump host file system interface

LIBRARY

     rump kernel (librump, -lrump)

SYNOPSIS

     #include <rump/rump.h>

     int
     rump_pub_etfs_register(const char *key, const char *hostpath, enum rump_etfs_type ftype);

     int
     rump_pub_etfs_register_withsize(const char *key, const char *hostpath, enum rump_etfs_type ftype, uint64_t begin, uint64_t size);

     int
     rump_pub_etfs_remove(const char *key);

DESCRIPTION

     The rump ExtraTerrestrial File System (rump_etfs) is used to provide access to the host file system namespace within a rump kernel.

     The operation is based on registered key values which each map to a hostpath.  A key must be an absolute path (i.e. begin with ``/'').  Mul-
     tiple leading slashes are collapsed to one (i.e.  ``/key'' is the same as ``//key'').  The rest of the path, including slashes, is compared
     verbatim (i.e.  ``/key/path'' does not match ``/key//path'').

     The hostpath is interpreted in host system context for the current working directory and can be either absolute or relative.

     The ftype parameter specifies how etfs file will be presented and does not have to match the host type, although some limitations apply.
     Possible values are:

     RUMP_ETFS_REG	       regular file.

     RUMP_ETFS_BLK	       block device.  This is often used when mapping file system images.

     RUMP_ETFS_CHR	       character device.

     RUMP_ETFS_DIR	       directory.  This option is valid only when hostpath is a directory.  The immediate children of the host directory
			       will be accessible inside a rump kernel.

     RUMP_ETFS_DIR_SUBDIRS     directory.  This option is valid only when hostpath is a directory.  This option recursively applies to all subdi-
			       rectories, and allows a rump kernel to access an entire directory tree.

     The interfaces are:

     rump_pub_etfs_register(key, hostpath, ftype)
	   Map key to a file of type ftype with the contents of hostpath.

     rump_pub_etfs_register_withsize(key, hostpath, ftype, begin, size)
	   Like the above, but map only [begin, begin+size] from hostpath.  This is useful when mapping disk images where only one partition is
	   relevant to the application.  If size is given the special value RUMP_ETFS_SIZE_ENDOFF, the underlying file is mapped from begin to the
	   end of the file.

     rump_pub_etfs_remove(key)
	   Remove etfs mapping for key.  This routine may be called only if the file related to the mapping is not in use.

EXAMPLES

     Map a host image file to a mountable /dev/harddisk path using window offsets from the disklabel.

	   rump_pub_etfs_register_withsize("/dev/harddisk", "disk.img",
	       RUMP_ETFS_BLK,
	       pp->p_offset << DEV_BSHIFT, pp->p_size << DEV_BSHIFT);

     Make the host kernel module directory hierarchy available within the rump kernel.

	   rump_pub_etfs_register("/stand/i386/5.99.41",
	       "/stand/i386/5.99.41", RUMP_ETFS_DIR_SUBDIRS);

SEE ALSO

     rump(3)

HISTORY

     rump_etfs first appeared in NetBSD 6.0.

BSD
								 February 3, 2011							       BSD

RUMP_SERVER(1)						    BSD General Commands Manual 					    RUMP_SERVER(1)

NAME

     rump_server, rump_allserver -- rump kernel server

SYNOPSIS

     rump_server [-s] [-c ncpu] [-d drivespec] [-l library] [-m module] url

DESCRIPTION

     The rump_server utility is used to provide a rump kernel service.	Clients can use the system calls provided by rump_server via url.

     The difference between rump_server and rump_allserver is that rump_server offers only a minimalistic set of features, while rump_allserver
     provides all rump kernel components which were available when the system was built.  At execution time it is possible to load components from
     the command line as described in the options section.

     -c ncpu
	     Configure ncpu virtual CPUs on SMP-capable archs.	By default, the number of CPUs equals the number of CPUs on the host.

     -d drivespec
	     The argument drivespec maps a host file in the rump fs namespace.	The string drivespec must be of comma-separated ``name=value''
	     format and must contain the following tokens:

	     key	   Block device path in rump namespace.  This must be specified according to the rules for a key in rump_etfs(3).

	     hostpath	   Host file used for storage.	If the file does not exist, it will be created.

	     size	   Size of the mapping.  Similar to dd(1), this argument accepts a suffix as the multiplier for the number.  The special
			   value ``host'' indicates that the current size of hostpath will be used.  In this case it is assumed that hostpath
			   exists and is a regular file.

	     OR

	     disklabel	   Use a disklabel partition identifier to specify the offset and size of the mapping.	hostpath must contain an existing
			   and valid disklabel within the first 64k.

	     The following are optional:

	     offset	   Offset of the mapping.  The window into hostpath therefore is [offset, offset+size].  In case this parameter is not
			   given, the default value 0 is used.

	     type	   The type of file that key is exposed as within the rump kernel.  The possibilities are ``blk'', ``chr'', and ``reg''
			   for block device, character device and regular file, respectively.  The default is a block device.

			   Note: the contents of block devices are cached in the rump kernel's buffer cache.  To avoid cache incoherency, it is
			   advisable not to access a file through the host namespace while it is mapped as a block device in a rump kernel.

	     In case hostpath does not exist, it will be created as a regular file with mode 0644 (plus any restrictions placed by umask).  In
	     case hostpath is a regular file and is not large enough to accommodate the specified size, it will be extended to the specified size.

     -l library
	     Call dlopen() on library before initializing the rump kernel.  In case library provides a kernel module, it will appear as a builtin
	     module in the rump kernel.  Any rump component present in library will also be initialized.

	     The argument library can contain a full path or a filename, in which case the standard dynamic library search path will be used.
	     Libraries are loaded in the order they are given.	Dependencies are not autoloaded, and the order must be specified correctly.

     -m module
	     Load and link a kernel module after the rump kernel is initialized.  For this to work, the rump kernel must include the vfs faction,
	     since the module is loaded using kernel vfs code (see EXAMPLES).

     -r total_ram
	     Sets the limit of kernel memory allocatable by the server to total_ram as opposed to the default which allows the server to allocate
	     as much memory as the host will give it.  This parameter is especially useful for VFS servers, since by default the virtual file sys-
	     tem will attempt to consume as much memory as it can, and accessing large files can cause an excessive amount of memory to be used as
	     file system cache.

     -s      Do not detach from the terminal.  By default, rump_server detaches from the terminal once the service is running on url.

     -v      Set bootverbose.

     After use, rump_server can be made to exit using rump.halt(1).

EXAMPLES

     Start a server and load the tmpfs file system module, and halt the server immediately afterwards:

	   $ rump_server -lrumpvfs -m /modules/tmpfs.kmod unix://sock
	   $ env RUMP_SERVER=unix://sock rump.halt

     Start a server with the one gigabyte host file dk.img mapped as the block device /dev/dk in the rump kernel.

	   $ rump_allserver -d key=/dev/dk,hostpath=dk.img,size=1g unix://sock

     Start a server which listens on INADDR_ANY port 3755

	   $ rump_server tcp://0:3755/

     Start a FFS server with a 16MB kernel memory limit.

	   $ rump_server -lrumpvfs -lrumpfs_ffs -r 16m unix:///tmp/ffs_server

SEE ALSO

     rump.halt(1), dlopen(3), rump(3), rump_sp(7)

BSD
								 February 21, 2011							       BSD