mount(const char *source, const char
const char *filesystemtype, unsigned long
const void *data);
attaches the filesystem specified by source (which is
often a device name, but can also be a directory name or a
dummy) to the directory specified by target.
privilege (Linux: the CAP_SYS_ADMIN capability) is
required to mount filesystems.
Since Linux 2.4
a single filesystem can be visible at multiple mount points,
and multiple mounts can be stacked on the same mount
Values for the
filesystemtype argument supported by the kernel are
listed in /proc/filesystems (e.g., "minix",
"ext2", "ext3", "jfs",
"xfs", "reiserfs", "msdos",
"proc", "nfs", "iso9660").
Further types may become available when the appropriate
modules are loaded.
mountflags argument may have the magic number 0xC0ED
(MS_MGC_VAL) in the top 16 bits (this was required in
kernel versions prior to 2.4, but is no longer required and
ignored if specified), and various mount flags in the low
order 16 bits:
MS_BIND (Linux 2.4 onward)
Perform a bind mount, making a
file or a directory subtree visible at another point within
a filesystem. Bind mounts may cross filesystem boundaries
and span chroot(2) jails. The filesystemtype
and data arguments are ignored. Up until Linux
2.6.26, mountflags was also ignored (the bind mount
has the same mount options as the underlying mount
MS_DIRSYNC (since Linux
Make directory changes on this
filesystem synchronous. (This property can be obtained for
individual directories or subtrees using
MS_LAZYTIME (since Linux
Reduce on-disk updates of inode
timestamps (atime, mtime, ctime) by maintaining these
changes only in memory. The on-disk timestamps are updated
the inode needs to be updated for some change unrelated
to file timestamps;
the application employs fsync(2),
syncfs(2), or sync(2);
an undeleted inode is evicted from memory; or
more than 24 hours have passed since the inode was
written to disk.
option significantly reduces writes needed to update the
inode’s timestamps, especially mtime and atime.
However, in the event of a system crash, the atime and mtime
fields on disk might be out of date by up to 24 hours.
workloads where this option could be of significant benefit
include frequent random writes to preallocated files, as
well as cases where the MS_STRICTATIME mount option
is also enabled. (The advantage of combining
MS_STRICTATIME and MS_LAZYTIME is that
stat(2) will return the correctly updated atime, but
the atime updates will be flushed to disk only in the cases
Permit mandatory locking on
files in this filesystem. (Mandatory locking must still be
enabled on a per-file basis, as described in
Move a subtree. source
specifies an existing mount point and target
specifies the new location. The move is atomic: at no point
is the subtree unmounted. The filesystemtype,
mountflags, and data arguments are
Do not update access times for
(all types of) files on this filesystem.
Do not allow access to devices
(special files) on this filesystem.
Do not update access times for
directories on this filesystem. This flag provides a subset
of the functionality provided by MS_NOATIME; that is,
MS_NOATIME implies MS_NODIRATIME.
Do not allow programs to be
executed from this filesystem.
Do not honor set-user-ID and
set-group-ID bits when executing programs from this
Mount filesystem read-only.
MS_RELATIME (since Linux
When a file on this filesystem
is accessed, update the file’s last access time
(atime) only if the current value of atime is less than or
equal to the file’s last modification time (mtime) or
last status change time (ctime). This option is useful for
programs, such as mutt(1), that need to know when a
file has been read since it was last modified. Since Linux
2.6.30, the kernel defaults to the behavior provided by this
flag (unless MS_NOATIME was specified), and the
MS_STRICTATIME flag is required to obtain traditional
semantics. In addition, since Linux 2.6.30, the file’s
last access time is always updated if it is more than 1 day
Remount an existing mount. This
allows you to change the mountflags and data
of an existing mount without having to unmount and remount
the filesystem. target should be the same value
specified in the initial mount() call; source
and filesystemtype are ignored. The mountflags
and data arguments should match the values used in
the original mount() call, except for those
parameters that are being deliberately changed.
mountflags can be changed: MS_RDONLY,
MS_SYNCHRONOUS, MS_MANDLOCK; before kernel
2.6.16, the following could also be changed:
MS_NOATIME and MS_NODIRATIME; and,
additionally, before kernel 2.4.10, the following could also
be changed: MS_NOSUID, MS_NODEV,
MS_SILENT (since Linux
Suppress the display of certain
(printk()) warning messages in the kernel log. This
flag supersedes the misnamed and obsolete MS_VERBOSE
flag (available since Linux 2.4.12), which has the same
Always update the last access
time (atime) when files on this filesystem are accessed.
(This was the default behavior before Linux 2.6.30.)
Specifying this flag overrides the effect of setting the
MS_NOATIME and MS_RELATIME flags.
Make writes on this filesystem
synchronous (as though the O_SYNC flag to
open(2) was specified for all file opens to this
From Linux 2.4
onward, the MS_NODEV, MS_NOEXEC, and
MS_NOSUID flags are settable on a per-mount-point
basis. From kernel 2.6.16 onward, MS_NOATIME and
MS_NODIRATIME are also settable on a per-mount-point
basis. The MS_RELATIME flag is also settable on a
argument is interpreted by the different filesystems.
Typically it is a string of comma-separated options
understood by this filesystem. See mount(8) for
details of the options available for each filesystem
zero is returned. On error, −1 is returned, and
errno is set appropriately.
values given below result from filesystem type independent
errors. Each filesystem type may have its own special errors
and its own special behavior. See the Linux kernel source
code for details.
A component of a path was not searchable. (See also
path_resolution(7).) Or, mounting a read-only
filesystem was attempted without giving the MS_RDONLY
flag. Or, the block device source is located on a
filesystem mounted with the MS_NODEV option.
source is already mounted. Or, it cannot be
remounted read-only, because it still holds files open for
writing. Or, it cannot be mounted on target because
target is still busy (it is the working directory of
some thread, the mount point of another device, has open
One of the pointer arguments points outside the user
source had an invalid superblock. Or, a remount
(MS_REMOUNT) was attempted, but source was not
already mounted on target. Or, a move
(MS_MOVE) was attempted, but source was not a
mount point, or was '/'.
Too many links encountered during pathname resolution.
Or, a move was attempted, while target is a
descendant of source.
(In case no block device is required:) Table of dummy
devices is full.
A pathname was longer than
filesystemtype not configured in the kernel.
A pathname was empty or had a nonexistent component.
The kernel could not allocate a free page to copy
filenames or data into.
source is not a block
device (and a device was required).
target, or a prefix of
source, is not a directory.
The major number of the block device source is
out of range.
The caller does not have the required privileges.
of MS_DIRSYNC, MS_MOVE, MS_REC,
MS_RELATIME, and MS_STRICTATIME were added to
glibc headers in version 2.12.
is Linux-specific and should not be used in programs
intended to be portable.
MS_SYNC flag was renamed MS_SYNCHRONOUS in
1.1.69 when a different MS_SYNC was added to
2.4 an attempt to execute a set-user-ID or set-group-ID
program on a filesystem mounted with MS_NOSUID would
fail with EPERM. Since Linux 2.4 the set-user-ID and
set-group-ID bits are just silently ignored in this
Starting with kernel 2.4.19, Linux provides per-process
mount namespaces. A mount namespace is the set of filesystem
mounts that are visible to a process. Mount-point namespaces
can be (and usually are) shared between multiple processes,
and changes to the namespace (i.e., mounts and unmounts) by
one process are visible to all other processes sharing the
same namespace. (The pre-2.4.19 Linux situation can be
considered as one in which a single namespace was shared by
every process on the system.)
A child process
created by fork(2) shares its parent’s mount
namespace; the mount namespace is preserved across an
A process can
obtain a private mount namespace if: it was created using
the clone(2) CLONE_NEWNS flag, in which case
its new namespace is initialized to be a copy of the
namespace of the process that called clone(2); or it
calls unshare(2) with the CLONE_NEWNS flag,
which causes the caller’s mount namespace to obtain a
private copy of the namespace that it was previously sharing
with other processes, so that future mounts and unmounts by
the caller are invisible to other processes (except child
processes that the caller subsequently creates) and vice
Linux-specific /proc/PID/mounts file exposes the list
of mount points in the mount namespace of the process with
the specified ID; see proc(5) for details.
lsblk(8), mount(8), umount(8)
This page is
part of release 4.04 of the Linux man-pages project.
A description of the project, information about reporting
bugs, and the latest version of this page, can be found at