mount a loopback file system sub-tree; demonstrate
the use of a null file system layer
utility creates a null
layer, duplicating a sub-tree of the file system name space under another part
of the global file system namespace. This allows existing files and
directories to be accessed using a different pathname.
The primary differences between a virtual copy of the file system and a symbolic
link are that the
functions work correctly in the virtual copy, and that other file systems may
be mounted on the virtual copy without affecting the original. A different
device number for the virtual copy is returned by
but in other respects it is indistinguishable from the original.
file system differs from a
traditional loopback file system in two respects: it is implemented using a
stackable layers techniques, and its “null-node”s stack above
all lower-layer vnodes, not just over directory vnodes.
The options are as follows:
- Options are specified with a
followed by a comma separated string of options. See the
man page for possible options and their meanings.
The null layer has two purposes. First, it serves as a demonstration of layering
by providing a layer which does nothing. (It actually does everything the
loopback file system does, which is slightly more than nothing.) Second, the
null layer can serve as a prototype layer. Since it provides all necessary
layer framework, new file system layers can be created very easily by starting
with a null layer.
The remainder of this man page examines the null layer as a basis for
constructing new layers.
New null layers are created with
utility takes two arguments,
the pathname of the lower vfs (target-pn) and the pathname where the null
layer will appear in the namespace (mount-point-pn). After the null layer is
put into place, the contents of target-pn subtree will be aliased under
The null layer is the minimum file system layer, simply bypassing all possible
operations to the lower layer for processing there. The majority of its
activity centers on the bypass routine, through which nearly all vnode
The bypass routine accepts arbitrary vnode operations for handling by the lower
layer. It begins by examining vnode operation arguments and replacing any
null-nodes by their lower-layer equivalents. It then invokes the operation on
the lower layer. Finally, it replaces the null-nodes in the arguments and, if
a vnode is returned by the operation, stacks a null-node on top of the
Although bypass handles most operations,
are not bypassed.
must change the fsid being returned.
are not bypassed so that they can
handle freeing null-layer specific data.
is not bypassed to avoid excessive
Mounting associates the null layer with a lower layer, in effect stacking two
VFSes. Vnode stacks are instead created on demand as files are accessed.
The initial mount creates a single vnode stack for the root of the new null
layer. All other vnode stacks are created as a result of vnode operations on
this or other null vnode stacks.
New vnode stacks come into existence as a result of an operation which returns a
vnode. The bypass routine stacks a null-node above the new vnode before
returning it to the caller.
For example, imagine mounting a null layer with
mount_nullfs /usr/include /dev/layer/null
Changing directory to /dev/layer/null
assign the root null-node (which was created when the null layer was mounted).
Now consider opening sys
. A vop_lookup
would be done on the root null-node. This operation would bypass through to
the lower layer which would return a vnode representing the UFS
. Null_bypass then builds a null-node
aliasing the UFS sys
and returns this to
the caller. Later operations on the null-node
will repeat this process when
constructing other vnode stacks.
One of the easiest ways to construct new file system layers is to make a copy of
the null layer, rename all files and variables, and then begin modifying the
utility can be used to easily rename all variables.
The umap layer is an example of a layer descended from the null layer.
There are two techniques to invoke operations on a lower layer when the
operation cannot be completely bypassed. Each method is appropriate in
different situations. In both cases, it is the responsibility of the aliasing
layer to make the operation arguments "correct" for the lower layer
by mapping a vnode argument to the lower layer.
The first approach is to call the aliasing layer's bypass routine. This method
is most suitable when you wish to invoke the operation currently being handled
on the lower layer. It has the advantage that the bypass routine already must
do argument mapping. An example of this is
in the null layer.
A second approach is to directly invoke vnode operations on the lower layer with
interface. The advantage of
this method is that it is easy to invoke arbitrary operations on the lower
layer. The disadvantage is that vnode arguments must be manually mapped.
UCLA Technical Report CSD-910056, Stackable Layers: an
Architecture for File System Development
utility first appeared in
. It was renamed to