Union mount

Incomputeroperating systems,union mountingis a way of combining multiple directories into one that appears to contain their combined contents.Union mounting is supported inLinux,BSDand several of its successors, andPlan 9,with similar but subtly different behavior.

As an example application of union mounting, consider the need to update the information contained on aCD-ROMorDVD.While a CD-ROM is not writable, one can overlay the CD'smount pointwith a writable directory in a union mount. Then, updating files in the union directory will cause them to end up in the writable directory, giving the illusion that the CD-ROM's contents have been updated.

Implementations

Plan 9

Main article:Plan 9 from Bell Labs § Union directories and namespaces

In the Plan 9 operating system fromBell Labs(mid-1980s onward), union mounting is a central concept, replacing several olderUnixconventions with union directories; for example, several directories containingexecutables,unioned together at a single/bindirectory, replace thePATHvariable for command lookup in the shell.

Plan 9 union semantics are greatly simplified compared to the implementations forPOSIX-style operating systems: the union of two directories is simply the concatenation of their contents, so a directory listing of the union may display duplicate names. Also, no effort is made to recursively merge subdirectories, leading to an extremely simple implementation.Directories are unioned in a controllable order;u/name,whereuis a union directory, denotes the file callednamein the first constituent directory that contains such a file.

Unix and BSD

Unix/POSIX implementations of unions have requirements different from the Plan 9 implementation due to constraints in the traditional Unix file system behavior, which greatly complicates their implementation and often leads to compromises.Problems that union mounting on Unix-like operating systems encounters include:

• Duplicate file names within a directory are not acceptable, since this would break applications' expectations of how a Unix file system works. Putting a logical,stack-like precedence ordering on the union's constituents partially solves this problem, but requires memory to record which files need to be skipped over during a directory listing (which is otherwise a nearly stateless operation).
• Deletion requires special support: if files with the same name exist in several of the union directory's constituents, simply deleting it from one of the constituents causes a file from one of the others to reappear in its stead.
• Insertion of a directory into the stack can cause incoherency in thekernel's file name cache.
• Renaming a file within a single mounted file system (using therenamesystem call) should be anatomic operation,but renaming within a union mount can require changes to multiple of the union's constituent directories. A possible solution is to disallowrenamein such situations and require implementations to copy-and-delete instead.
• Stableinodenumbers for files,hard linksandmemory-mapped I/O(mmap) are hard to implement correctly.

Early attempts to add unioning to Unix filesystems included the 3-d filesystem (Bell Labs) and the Translucent File Service inSunOS(Sun Microsystems,1988). An implementation of union mounting was added to the BSD version of Unix in version4.4(1994), taking inspiration from these earlier attempts, Plan 9 and the stackable file systems inSpring(Sun, 1994).4.4BSD implements the stack-of-directories approach outlined above. As in Plan 9, operations traverse this stack top-down to resolve names, but unlike Plan 9, BSD union mounts are recursive, so that the contents of subdirectories appear merged in the union directory. Also unlike the Plan 9 version, all layers except the top are read-only: modifying files in the union causes their contents to first be copied into the top layer of the stack, where the modifications are then applied. Deletion of files is implemented by writing aspecial type of filecalled awhiteoutto the top directory, which has the effect of marking the file name as non-existent and hiding files with the same name in the lower layers of the stack.Whiteouts require support from the underlying file system.

Linux

Union mounting was implemented for Linux 0.99 in 1993; this initial implementation was called the Inheriting File System, but was abandoned by its developer because of its complexity.The next major implementation wasUnionFS,which grew out of theFiSTproject atStony Brook University.An attempt to replace UnionFS,aufs,was released in 2006, followed in 2009 byOverlayFS.In 2014OverlayFSunion mount implementation was added to the standardLinux kernelsource code.

Similarly,GlusterFSoffers the ability to mount different filesystems distributed across a network, rather than being located on the same machine.

MergerFS,originally released in 2014, is an actively developed open-sourceFUSE plugin,allowing pooling of arbitrary directories.