What Is A Mount Point In Linux : Mount Point Filesystem Location

by

A mount point in Linux is a directory that you use to access the files on a separate storage device or partition. If you’ve ever plugged in a USB drive and seen its contents appear under `/media/username/`, you’ve already used a mount point. This concept is fundamental to how Linux handles storage—it’s not about drive letters like C: or D:, but about attaching filesystems to your directory tree.

Think of your Linux system as a big tree starting from the root (`/`). Every file and folder lives somewhere under that root. When you add a new disk or partition, you need to attach it to a specific empty directory—that directory becomes the mount point. Once mounted, you can read and write files on that device just like any other folder.

Understanding mount points is key to managing disks, setting up servers, or even troubleshooting storage issues. Let’s break down everything you need to know, from basic commands to real-world examples.

What Is A Mount Point In Linux

A mount point is simply an existing directory in your Linux filesystem that serves as the entry point for a separate storage device or filesystem. When you mount a device, its contents become accessible through that directory. The original contents of the mount point directory (if any) become hidden until the device is unmounted.

For example, if you have a hard drive with your music collection, you might mount it at `/mnt/music`. After mounting, typing `ls /mnt/music` shows all your songs. The mount point itself is just a regular directory—it doesn’t need special permissions beyond what you set.

Linux uses a single unified directory tree. Unlike Windows where each drive gets its own letter (C:, D:), Linux integrates everything under root. This makes mount points incredibly flexible. You can mount a USB stick at `/media/usb`, a network share at `/mnt/nas`, or even a RAM disk at `/tmp/ramdisk`.

How Mount Points Work Under The Hood

When you mount a filesystem, the kernel attaches it to a specific point in the virtual filesystem (VFS) tree. The VFS is an abstraction layer that allows different filesystem types (ext4, NTFS, FAT32) to work seamlessly. The mount point directory becomes the “gateway” to that filesystem’s root.

Every mounted filesystem has a superblock that contains metadata about the filesystem. The kernel uses this to manage reads and writes. The mount point itself is just a directory entry in the parent filesystem’s inode table.

You can see all active mount points by running `mount` without arguments or by checking `/proc/mounts`. Each line shows the device, mount point, filesystem type, and options.

Key Components Of A Mount Command

  • Device: The block device (e.g., `/dev/sdb1`) or remote share (e.g., `192.168.1.100:/share`)
  • Mount point: The directory where the filesystem will appear
  • Filesystem type: Usually auto-detected, but can be specified (ext4, xfs, ntfs)
  • Options: Permissions, read-only, noexec, etc.
  • Dump and pass: Used for backup and fsck ordering (rarely needed manually)

Why Mount Points Matter In Linux

Mount points give you granular control over storage. You can isolate system files from user data, mount network drives, or create temporary workspaces. Without mount points, you’d be stuck with a single monolithic filesystem.

Here are some practical reasons mount points are essential:

  • Separation of concerns: Keep `/home` on a separate partition so reinstalling the OS doesn’t wipe your data
  • Performance: Mount a fast SSD for `/var` if you run database servers
  • Security: Mount sensitive partitions with `noexec` or `nosuid` to prevent malware
  • Flexibility: Easily swap storage devices without rebuilding your system
  • Network storage: Mount NFS or Samba shares to access remote files as if they were local

Common Mount Points In A Typical Linux System

Most Linux distributions create several mount points during installation. Here’s what you’ll usually find:

  • / (root): The base of the entire filesystem tree
  • /boot: Contains kernel images and bootloader files (often a separate partition)
  • /home: User home directories (separate partition is common)
  • /var: Variable data like logs, databases, and spool files
  • /tmp: Temporary files (often mounted as tmpfs in RAM)
  • /proc: Virtual filesystem for process and kernel information
  • /sys: Virtual filesystem for device and driver information
  • /dev: Device files (managed by udev)
  • /run: Runtime variable data (tmpfs)
  • /media: Default mount point for removable media (USB, CD-ROM)
  • /mnt: Temporary mount point for manual mounts

How To Create And Use Mount Points

Creating a mount point is straightforward. You need an empty directory and a device or filesystem to mount. Let’s walk through the process step by step.

Step 1: Identify Your Device

First, find the device you want to mount. Use `lsblk` or `fdisk -l` to list available disks and partitions. For example:

lsblk
NAME   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
sda      8:0    0 238.5G  0 disk
├─sda1   8:1    0   512M  0 part /boot
├─sda2   8:2    0 237.1G  0 part /
└─sda3   8:3    0   976M  0 part [SWAP]
sdb      8:16   1  14.9G  0 disk
└─sdb1   8:17   1  14.9G  0 part /media/usb0

Here, `/dev/sdb1` is a USB drive already mounted at `/media/usb0`. If it weren’t mounted, you’d see no MOUNTPOINT.

Step 2: Create The Mount Point Directory

Choose or create an empty directory. Standard locations are `/mnt` for temporary mounts and `/media` for removable media. Use `mkdir`:

sudo mkdir /mnt/mydrive

Make sure the directory is empty. If it contains files, they’ll be hidden while the device is mounted.

Step 3: Mount The Device

Use the `mount` command with the device and mount point:

sudo mount /dev/sdb1 /mnt/mydrive

You can also specify the filesystem type if auto-detection fails:

sudo mount -t ext4 /dev/sdb1 /mnt/mydrive

Step 4: Verify The Mount

Check that the mount succeeded with `mount` or `df -h`:

mount | grep /mnt/mydrive
/dev/sdb1 on /mnt/mydrive type ext4 (rw,relatime)

Now you can access files in `/mnt/mydrive` as if they were part of your local filesystem.

Step 5: Unmount When Done

To safely remove the device, unmount it with `umount` (note the spelling—no ‘n’):

sudo umount /mnt/mydrive

Always unmount before physically disconnecting a drive to avoid data corruption.

Persistent Mounts With /Etc/fstab

Manual mounts disappear after a reboot. To make mounts permanent, add an entry to `/etc/fstab`. This file tells the system which filesystems to mount at boot time.

Each line in fstab has six fields:

  1. Device: UUID or device path (UUID is preferred for reliability)
  2. Mount point: Directory where it will be mounted
  3. Filesystem type: ext4, xfs, ntfs, etc.
  4. Options: defaults, noatime, rw, etc.
  5. Dump: Backup flag (usually 0)
  6. Pass: fsck order (1 for root, 2 for others, 0 to skip)

Example fstab entry for a data partition:

UUID=abc12345-6789-def0-1234-56789abcdef0 /mnt/data ext4 defaults 0 2

To find your device’s UUID, run `blkid`:

sudo blkid /dev/sdb1
/dev/sdb1: UUID="abc12345-..." TYPE="ext4"

After editing fstab, test the entry with `mount -a` to mount all filesystems listed. If there’s an error, fix it before rebooting—a bad fstab can prevent your system from booting.

Common Mount Options

  • defaults: rw, suid, dev, exec, auto, nouser, async
  • ro: Mount read-only
  • noexec: Prevent execution of binaries on the filesystem
  • nosuid: Ignore setuid and setgid bits
  • noatime: Don’t update access times (improves performance)
  • user: Allow regular users to mount (useful for removable media)

Special Mount Points: Bind Mounts And Tmpfs

Beyond standard device mounts, Linux supports several special types of mount points that are incredibly useful.

Bind Mounts

A bind mount makes a directory or file accessible at another location without copying it. It’s like a hard link for directories. Use the `–bind` option:

sudo mount --bind /home/user/projects /mnt/projects

Now `/mnt/projects` shows the same content as `/home/user/projects`. Changes in one location appear in the other. This is great for chroot environments, containers, or reorganizing your filesystem without moving files.

Tmpfs Mounts

Tmpfs is a temporary filesystem that lives in RAM (and swap if needed). It’s perfect for `/tmp` or any volatile data. Mount it like this:

sudo mount -t tmpfs -o size=1G tmpfs /mnt/ramdisk

Everything in `/mnt/ramdisk` disappears on reboot. Tmpfs is blazing fast but consumes memory. Use it for cache, session data, or build artifacts.

Overlay Mounts

Overlay filesystems combine multiple directories into one view. Docker uses overlay mounts extensively. You can create one with:

sudo mount -t overlay overlay -o lowerdir=/lower,upperdir=/upper,workdir=/work /merged

This gives you a merged view where changes go to the upper directory. It’s powerful for read-only base systems with writable overlays.

Mount Points And Systemd

Modern Linux systems use systemd to manage mount points. You can create a `.mount` unit file for persistent mounts instead of editing fstab. For example, to mount `/mnt/data` automatically, create `/etc/systemd/system/mnt-data.mount`:

[Unit]
Description=Data partition mount

[Mount]
What=/dev/sdb1
Where=/mnt/data
Type=ext4
Options=defaults

[Install]
WantedBy=multi-user.target

Then enable it:

sudo systemctl enable mnt-data.mount
sudo systemctl start mnt-data.mount

Systemd mount units are more flexible and integrate with the rest of the systemd ecosystem. They can have dependencies, ordering, and automatic restart on failure.

Troubleshooting Mount Point Issues

Even experienced Linux users run into mount problems. Here are common issues and fixes.

Device Is Busy

If you get “device is busy” when trying to unmount, some process is using files on the filesystem. Use `lsof` or `fuser` to find the culprit:

sudo lsof /mnt/mydrive
sudo fuser -v /mnt/mydrive

Kill the offending process or close the file manager, then try unmounting again. You can also force unmount with `umount -l` (lazy unmount) but this can cause data loss.

Mount Point Not Empty

If you try to mount on a directory that contains files, the mount succeeds but the original files become invisible. This is confusing but not an error. Always mount on empty directories, or move the original files elsewhere first.

Filesystem Not Recognized

If `mount` fails with “wrong fs type”, you might need to install the appropriate driver. For NTFS, install `ntfs-3g`. For exFAT, install `exfat-utils` or `fuse-exfat`.

Permission Denied

Mounting requires root privileges by default. To allow regular users to mount, add the `user` option in fstab or use `udisksctl` (part of udisks2) which handles permissions via polkit.

Real-World Examples Of Mount Points

Let’s look at how mount points are used in everyday Linux scenarios.

Example 1: Mounting A USB Drive

Plug in a USB drive, and most desktop environments auto-mount it under `/media/username/DRIVELABEL`. If you prefer the command line:

sudo mkdir /media/usb
sudo mount /dev/sdb1 /media/usb
# Access files
ls /media/usb
# When done
sudo umount /media/usb

Example 2: Setting Up A Separate Home Partition

During installation, you can create a separate partition for `/home`. This means if you reinstall the OS, your documents, settings, and downloads survive. The fstab entry might look like:

UUID=... /home ext4 defaults 0 2

Example 3: Mounting An ISO File

You can mount ISO images using the loop device:

sudo mkdir /mnt/iso
sudo mount -o loop ubuntu.iso /mnt/iso

Now you can browse the ISO contents without burning it to a disc.

Example 4: Network Share With NFS

Mount a remote NFS share:

sudo mkdir /mnt/nas
sudo mount -t nfs 192.168.1.100:/shared /mnt/nas

Add to fstab for automatic mounting:

192.168.1.100:/shared /mnt/nas nfs defaults 0 0

Security Considerations For Mount Points

Mount points can introduce security risks if not configured properly. Here are best practices:

  • Use noexec on removable media: Prevents malware from running
  • Use nosuid on user-mounted drives: Blocks privilege escalation
  • Mount sensitive data with ro: Read-only prevents accidental changes
  • Restrict automounting: Disable auto-mount for untrusted devices
  • Monitor mount points: Check `/proc/mounts` for unexpected mounts

Performance Tuning With Mount Options

You can optimize mount points for specific workloads. For databases, use `noatime` to reduce write overhead. For SSD drives, consider `discard` for TRIM support (though modern SSDs handle this automatically).

Example for a database server’s data partition:

UUID=... /var/lib/mysql ext4 noatime,nodiratime,data=ordered 0 2