Exploring Bind Mounts: What They Are And How To Use Them

What Are Bind Mounts and Why Use Them

A bind mount is a special type of mount in Linux that allows you to create a mirror of a directory structure in another location. It involves mounting an existing filesystem somewhere else while retaining the same permissions and semantics.

The key difference compared to symbolic links is that bind mounts establish a true bidirectional connection. Changes made to the original directory propagate to the bind mount, and vice versa. This allows seamless integration and customizations.

Common use cases for leveraging bind mounts include:

Table of Contents

Customizing root directory environments
Overriding configuration files
Sharing directories between containers
Merging multiple disks into unified structures

Overall, bind mounts provide immense flexibility since you can restructure filesystem resources without needing to modify anything. This powerful capability enables simpler organization and access patterns.

How Bind Mounts Work Under the Hood

To understand bind mounts, you need to first grasp Linux mount namespaces. A mount namespace encapsulates a distinct set of mounted filesystems for a process group. This prevents the filesystem hierarchy from being affected globally.

Bind mounts can either be private or shared. A private bind mount only propagates to the local namespace, while a shared one publishes the mount to children namespaces. You control the propagation mode using MS_PRIVATE, MS_SHARED, and MS_SLAVE options.

For example, a recursive shared bind mount on /source/dir mounted at /dest/dir makes /dest/dir a mirror that shows all current and future contents of /source/dir seamlessly across namespaces.

Creating Bind Mounts in Linux

The syntax for creating a bind mount is:

# mount --bind /source/dir /dest/dir

Common flags used include:

--bind – Specifies a bind mount operation
-o ro – Sets up a read-only bind mount
-o rw – Sets up a read-write bind mount
-o recursive – Includes sub-directories recursively

For example, a read-only recursive bind mount is created with:

# mount -o ro,recursive /source/dir /dest/dir

To unmount the bound filesystem, simply run:

# umount /dest/dir

Use Cases and Practical Examples

Bind mounts enable very flexible filesystem management through mounting manipulation. Some common use cases include:

Customizing Root Directories

Bind mounts allow customization of root (/) directories without tampering the global filesystem. This helps create jailed environments for users while retaining host access as needed.

# mount -o ro,bind /usr /chroot/myjail/usr

Merging Directories from Multiple Disks

You can seamlessly merge directories across multiple disks with bind mounts. This helps establish unified directory trees instead of splitting data across drives.

# mount -o bind /disk1/videos /disk2/videos

Sharing Configuration Files Between Containers

Bind mounts provide an easy way to share configuration files across containers. Just mount the host config directory into containers using --volume or -v flags.

$ docker run -v /src/config:/dest/config myimage

Troubleshooting Common Bind Mount Issues

There are a few common problems faced when working with bind mounts:

Permission Problems and Ownership

The bind mount retains the same ownership and permissions as the original source directory. You may need to adjust using chmod or chown to resolve access issues.

Mount Propagation Confusion

Sort out propagation with findmnt --target /dest to validate if mount is private or shared as expected. Use bind mount flags to control propagation explicitly.

Unmounting Stuck Bind Mounts

Use umount -l to force unmount stubborn bind mounts, or fuser -km to kill processes preventing the unmount.