mount
mount
The mount
command in Unix and Linux is used to attach a filesystem to a specified directory in the directory tree. Conversely, the umount
command detaches a filesystem. Understanding how to use these commands is crucial for managing filesystems, storage devices, and partitions.
Basic Usage
The basic syntax for mount
is:
mount [options] device dir
device
: The device or partition to mount (e.g.,/dev/sda1
).dir
: The directory where the device is to be mounted.
Mounting a Filesystem
To mount a filesystem, you need to specify the device and the directory where you want it to be mounted. You must have the necessary permissions (typically root) to perform the mount operation.
Example
Mounting /dev/sda1
to /mnt
:
sudo mount /dev/sda1 /mnt
Viewing Mounted Filesystems
To view all currently mounted filesystems:
mount
Or using a more concise format:
findmnt
Options
The mount
command comes with various options that can be used to modify its behavior.
Common Options
-t
type: Specifies the filesystem type (e.g.,ext4
,vfat
,ntfs
).-o
options: Specifies mount options, such asrw
(read/write),ro
(read-only),noexec
(do not execute binaries),nosuid
(ignore set-user-identifier or set-group-identifier bits), and many more.-a
: Mount all filesystems mentioned in/etc/fstab
.-r
: Mount the filesystem as read-only.
Example
Mounting with specific options (read-only):
sudo mount -o ro /dev/sda1 /mnt
Mounting with a specified filesystem type:
sudo mount -t ext4 /dev/sda1 /mnt
Unmounting a Filesystem
To unmount a filesystem, use the umount
command followed by the mount point or the device name.
Example
Unmounting the filesystem mounted at /mnt
:
sudo umount /mnt
Or using the device name:
sudo umount /dev/sda1
Mounting Filesystems Automatically
Filesystems can be automatically mounted at boot time by adding an entry to the /etc/fstab
file. Each line in /etc/fstab
describes a filesystem to be mounted, using the following format:
device mountpoint fstype options dump pass
Example /etc/fstab
Entry
Mounting /dev/sda1
to /mnt
with read-only access:
/dev/sda1 /mnt ext4 defaults,ro 0 2
Examples with Explanations
Mounting a USB Drive
Assume you have a USB drive at /dev/sdb1
and you want to mount it to /media/usb
.
Create the Mount Point:
sudo mkdir -p /media/usb
Mount the USB Drive:
sudo mount /dev/sdb1 /media/usb
Verify the Mount:
mount | grep /media/usb
Mounting an ISO File
To mount an ISO file (example.iso
) to /mnt/iso
:
Create the Mount Point:
sudo mkdir -p /mnt/iso
Mount the ISO File:
sudo mount -o loop example.iso /mnt/iso
Verify the Mount:
mount | grep /mnt/iso
Unmounting a Network Filesystem
Assume you have a network filesystem mounted at /mnt/nfs
:
sudo umount /mnt/nfs
Practical Use Cases
Mounting External Drives: Attach external storage devices like USB drives, external hard drives, or SD cards.
Network Storage: Mount network file systems such as NFS (Network File System) or CIFS (Common Internet File System).
ISO Files: Access the contents of ISO files without burning them to a disk.
Read-Only Mounts: Mount filesystems in read-only mode for safety.
Summary
The mount
and umount
commands are fundamental tools for managing filesystems in Unix and Linux systems. They allow you to attach and detach filesystems, providing flexibility in how storage devices and partitions are used. Understanding these commands helps in managing storage effectively, whether it's for daily use, troubleshooting, or system administration tasks.
help
Usage:
mount [-lhV]
mount -a [options]
mount [options] [--source] <source> | [--target] <directory>
mount [options] <source> <directory>
mount <operation> <mountpoint> [<target>]
Mount a filesystem.
Options:
-a, --all mount all filesystems mentioned in fstab
-c, --no-canonicalize don't canonicalize paths
-f, --fake dry run; skip the mount(2) syscall
-F, --fork fork off for each device (use with -a)
-T, --fstab <path> alternative file to /etc/fstab
-i, --internal-only don't call the mount.<type> helpers
-l, --show-labels show also filesystem labels
-m, --mkdir[=<mode>] alias to '-o X-mount.mkdir[=<mode>]'
-n, --no-mtab don't write to /etc/mtab
--options-mode <mode>
what to do with options loaded from fstab
--options-source <source>
mount options source
--options-source-force
force use of options from fstab/mtab
-o, --options <list> comma-separated list of mount options
-O, --test-opts <list> limit the set of filesystems (use with -a)
-r, --read-only mount the filesystem read-only (same as -o ro)
-t, --types <list> limit the set of filesystem types
--source <src> explicitly specifies source (path, label, uuid)
--target <target> explicitly specifies mountpoint
--target-prefix <path>
specifies path used for all mountpoints
-v, --verbose say what is being done
-w, --rw, --read-write mount the filesystem read-write (default)
-N, --namespace <ns> perform mount in another namespace
-h, --help display this help
-V, --version display version
Source:
-L, --label <label> synonym for LABEL=<label>
-U, --uuid <uuid> synonym for UUID=<uuid>
LABEL=<label> specifies device by filesystem label
UUID=<uuid> specifies device by filesystem UUID
PARTLABEL=<label> specifies device by partition label
PARTUUID=<uuid> specifies device by partition UUID
ID=<id> specifies device by udev hardware ID
<device> specifies device by path
<directory> mountpoint for bind mounts (see --bind/rbind)
<file> regular file for loopdev setup
Operations:
-B, --bind mount a subtree somewhere else (same as -o bind)
-M, --move move a subtree to some other place
-R, --rbind mount a subtree and all submounts somewhere else
--make-shared mark a subtree as shared
--make-slave mark a subtree as slave
--make-private mark a subtree as private
--make-unbindable mark a subtree as unbindable
--make-rshared recursively mark a whole subtree as shared
--make-rslave recursively mark a whole subtree as slave
--make-rprivate recursively mark a whole subtree as private
--make-runbindable recursively mark a whole subtree as unbindable
For more details see mount(8).
Last updated