Listing the mounts¶

The listing mode is maintained for backward compatibility only.

For more robust and customizable output use findmnt(8), especially in your scripts. Note that control characters in the mountpoint name are replaced with '?'.

The following command lists all mounted filesystems (of type type):

The option -l adds labels to this listing. See below.

Indicating the device and filesystem¶

Most devices are indicated by a filename (of a block special device), like /dev/sda1, but there are other possibilities. For example, in the case of an NFS mount, device may look like knuth.cwi.nl:/dir.

The device names of disk partitions are unstable; hardware reconfiguration, and adding or removing a device can cause changes in names. This is the reason why it’s strongly recommended to use filesystem or partition identifiers like UUID or LABEL. Currently supported identifiers (tags):

LABEL=label

UUID=uuid

PARTLABEL=label

PARTUUID=uuid

ID=id

The command lsblk --fs provides an overview of filesystems, LABELs and UUIDs on available block devices. The command blkid -p <device> provides details about a filesystem on the specified device.

Don’t forget that there is no guarantee that UUIDs and labels are really unique, especially if you move, share or copy the device. Use lsblk -o +UUID,PARTUUID to verify that the UUIDs are really unique in your system.

The recommended setup is to use tags (e.g. UUID=uuid) rather than /dev/disk/by-{label,uuid,id,partuuid,partlabel} udev symlinks in the /etc/fstab file. Tags are more readable, robust and portable. The mount(8) command internally uses udev symlinks, so the use of symlinks in /etc/fstab has no advantage over tags. For more details see libblkid(3).

The proc filesystem is not associated with a special device, and when mounting it, an arbitrary keyword - for example, proc - can be used instead of a device specification. (The customary choice none is less fortunate: the error message 'none already mounted' from mount can be confusing.)

The files /etc/fstab, /etc/mtab and /proc/mounts¶

The file /etc/fstab (see fstab(5)), may contain lines describing what devices are usually mounted where, using which options. The default location of the fstab(5) file can be overridden with the --fstab path command-line option (see below for more details).

The command

(usually given in a bootscript) causes all filesystems mentioned in fstab (of the proper type and/or having or not having the proper options) to be mounted as indicated, except for those whose line contains the noauto keyword. Adding the -F option will make mount fork, so that the filesystems are mounted in parallel.

When mounting a filesystem mentioned in fstab or mtab, it suffices to specify on the command line only the device, or only the mount point.

The programs mount and umount(8) traditionally maintained a list of currently mounted filesystems in the file /etc/mtab. The support for regular classic /etc/mtab is completely disabled at compile time by default, because on current Linux systems it is better to make /etc/mtab a symlink to /proc/mounts instead. The regular mtab file maintained in userspace cannot reliably work with namespaces, containers and other advanced Linux features. If the regular mtab support is enabled, then it’s possible to use the file as well as the symlink.

If no arguments are given to mount, the list of mounted filesystems is printed.

If you want to override mount options from /etc/fstab, you have to use the -o option:

and then the mount options from the command line will be appended to the list of options from /etc/fstab. This default behaviour can be changed using the --options-mode command-line option. The usual behavior is that the last option wins if there are conflicting ones.

The mount program does not read the /etc/fstab file if both device (or LABEL, UUID, ID, PARTUUID or PARTLABEL) and dir are specified. For example, to mount device foo at /dir:

This default behaviour can be changed by using the --options-source-force command-line option to always read configuration from fstab. For non-root users mount always reads the fstab configuration.

Non-superuser mounts¶

Normally, only the superuser can mount filesystems. However, when fstab contains the user option on a line, anybody can mount the corresponding filesystem.

Thus, given a line

any user can mount the iso9660 filesystem found on an inserted CDROM using the command:

Note that mount is very strict about non-root users and all paths specified on command line are verified before fstab is parsed or a helper program is executed. It’s strongly recommended to use a valid mountpoint to specify filesystem, otherwise mount may fail. For example it’s a bad idea to use NFS or CIFS source on command line.

Since util-linux 2.35, mount does not exit when user permissions are inadequate according to libmount’s internal security rules. Instead, it drops suid permissions and continues as regular non-root user. This behavior supports use-cases where root permissions are not necessary (e.g., fuse filesystems, user namespaces, etc).

For more details, see fstab(5). Only the user that mounted a filesystem can unmount it again. If any user should be able to unmount it, then use users instead of user in the fstab line. The owner option is similar to the user option, with the restriction that the user must be the owner of the special file. This may be useful e.g. for /dev/fd if a login script makes the console user owner of this device. The group option is similar, with the restriction that the user must be a member of the group of the special file.

The user mount option is accepted if no username is specified. If used in the format user=someone, the option is silently ignored and visible only for external mount helpers (/sbin/mount.<type>) for compatibility with some network filesystems.

Bind mount operation¶

Remount part of the file hierarchy somewhere else. The call is:

or by using this fstab entry:

After this call the same contents are accessible in two places.

It is important to understand that "bind" does not create any second-class or special node in the kernel VFS. The "bind" is just another operation to attach a filesystem. There is nowhere stored information that the filesystem has been attached by a "bind" operation. The olddir and newdir are independent and the olddir may be unmounted.

One can also remount a single file (on a single file). It’s also possible to use a bind mount to create a mountpoint from a regular directory, for example:

The bind mount call attaches only (part of) a single filesystem, not possible submounts. The entire file hierarchy including submounts can be attached a second place by using:

Note that the filesystem mount options maintained by the kernel will remain the same as those on the original mount point. The userspace mount options (e.g., _netdev) will not be copied by mount and it’s necessary to explicitly specify the options on the mount command line.

Since util-linux 2.27 mount permits changing the mount options by passing the relevant options along with --bind. For example:

This feature is not supported by the Linux kernel; it is implemented in userspace by an additional mount(2) remounting system call. This solution is not atomic.

The alternative (classic) way to create a read-only bind mount is to use the remount operation, for example:

Note that a read-only bind will create a read-only mountpoint (VFS entry), but the original filesystem superblock will still be writable, meaning that the olddir will be writable, but the newdir will be read-only.

It’s also possible to change nosuid, nodev, noexec, noatime, nodiratime, relatime and nosymfollow VFS entry flags via a "remount,bind" operation. The other flags (for example filesystem-specific flags) are silently ignored. The classic mount(2) system call does not allow to change mount options recursively (for example with -o rbind,ro). The recursive semantic is possible with a new mount_setattr(2) kernel system call and it’s supported since libmount from util-linux v2.39 by a new experimental "recursive" option argument (e.g. -o rbind,ro=recursive). For more details see the FILESYSTEM-INDEPENDENT MOUNT OPTIONS section.

Since util-linux 2.31, mount ignores the bind flag from /etc/fstab on a remount operation (if -o remount is specified on command line). This is necessary to fully control mount options on remount by command line. In previous versions the bind flag has been always applied and it was impossible to re-define mount options without interaction with the bind semantic. This mount behavior does not affect situations when "remount,bind" is specified in the /etc/fstab file.

The move operation¶

Move a mounted tree to another place (atomically). The call is:

This will cause the contents which previously appeared under olddir to now be accessible under newdir. The physical location of the files is not changed. Note that olddir has to be a mountpoint.

Note also that moving a mount residing under a shared mount is invalid and unsupported. Use findmnt -o TARGET,PROPAGATION to see the current propagation flags.

Shared subtree operations¶

Since Linux 2.6.15 it is possible to mark a mount and its submounts as shared, private, slave or unbindable. A shared mount provides the ability to create mirrors of that mount such that mounts and unmounts within any of the mirrors propagate to the other mirror. A slave mount receives propagation from its master, but not vice versa. A private mount carries no propagation abilities. An unbindable mount is a private mount which cannot be cloned through a bind operation. The detailed semantics are documented in Documentation/filesystems/sharedsubtree.txt file in the kernel source tree; see also mount_namespaces(7).

Supported operations are:

mount --make-shared mountpoint
mount --make-slave mountpoint
mount --make-private mountpoint
mount --make-unbindable mountpoint

The following commands allow one to recursively change the type of all the mounts under a given mountpoint.

mount --make-rshared mountpoint
mount --make-rslave mountpoint
mount --make-rprivate mountpoint
mount --make-runbindable mountpoint

mount does not read fstab(5) when a --make-* operation is requested. All necessary information has to be specified on the command line.

Note that the Linux kernel does not allow changing multiple propagation flags with a single mount(2) system call, and the flags cannot be mixed with other mount options and operations.

Since util-linux 2.23 the mount command can be used to do more propagation (topology) changes by one mount(8) call and do it also together with other mount operations. The propagation flags are applied by additional mount(2) system calls when the preceding mount operations were successful. Note that this use case is not atomic. It is possible to specify the propagation flags in fstab(5) as mount options (private, slave, shared, unbindable, rprivate, rslave, rshared, runbindable).

For example:

mount --make-private --make-unbindable /dev/sda1 /foo

is the same as:

mount /dev/sda1 /foo
mount --make-private /foo
mount --make-unbindable /foo

Mount options for adfs¶

uid=value and gid=value

ownmask=value and othmask=value

Mount options for affs¶

uid=value and gid=value

setuid=value and setgid=value

mode=value

protect

usemp

verbose

prefix=string

volume=string

reserved=value

root=value

bs=value

grpquota|noquota|quota|usrquota

Mount options for debugfs¶

The debugfs filesystem is a pseudo filesystem, traditionally mounted on /sys/kernel/debug. As of kernel version 3.4, debugfs has the following options:

uid=n, gid=n

mode=value

Mount options for devpts¶

The devpts filesystem is a pseudo filesystem, traditionally mounted on /dev/pts. In order to acquire a pseudo terminal, a process opens /dev/ptmx; the number of the pseudo terminal is then made available to the process and the pseudo terminal slave can be accessed as /dev/pts/<number>.

uid=value and gid=value

mode=value

newinstance

ptmxmode=value

Mount options for fat¶

(Note: fat is not a separate filesystem, but a common part of the msdos, umsdos and vfat filesystems.)

blocksize={512|1024|2048}

uid=value and gid=value

umask=value

dmask=value

fmask=value

allow_utime=value

The default is set from 'dmask' option. (If the directory is writable, utime(2) is also allowed. I.e. ~dmask & 022)

Normally utime(2) checks that the current process is owner of the file, or that it has the CAP_FOWNER capability. But FAT filesystems don’t have UID/GID on disk, so the normal check is too inflexible. With this option you can relax it.

check=value

codepage=value

conv=mode

cvf_format=module

cvf_option=option

debug

discard

dos1xfloppy

errors={panic|continue|remount-ro}

fat={12|16|32}

iocharset=value

nfs={stale_rw|nostale_ro}

tz=UTC

time_offset=minutes

quiet

rodir

showexec

sys_immutable

flush

usefree

dots, nodots, dotsOK=[yes|no]

Mount options for hfs¶

creator=cccc, type=cccc

uid=n, gid=n

dir_umask=n, file_umask=n, umask=n

session=n

part=n

quiet

Mount options for hpfs¶

uid=value and gid=value

umask=value

case={lower|asis}

conv=mode

nocheck

Mount options for iso9660¶

ISO 9660 is a standard describing a filesystem structure to be used on CD-ROMs. (This filesystem type is also seen on some DVDs. See also the udf filesystem.)

Normal iso9660 filenames appear in an 8.3 format (i.e., DOS-like restrictions on filename length), and in addition all characters are in upper case. Also there is no field for file ownership, protection, number of links, provision for block/character devices, etc.

Rock Ridge is an extension to iso9660 that provides all of these UNIX-like features. Basically there are extensions to each directory record that supply all of the additional information, and when Rock Ridge is in use, the filesystem is indistinguishable from a normal UNIX filesystem (except that it is read-only, of course).

norock

nojoliet

check={r[elaxed]|s[trict]}

uid=value and gid=value

map={n[ormal]|o[ff]|a[corn]}

mode=value

unhide

block={512|1024|2048}

conv=mode

cruft

session=x

sbsector=xxx

The following options are the same as for vfat and specifying them only makes sense when using discs encoded using Microsoft’s Joliet extensions.

iocharset=value

utf8

Mount options for jfs¶

iocharset=name

resize=value

nointegrity

integrity

errors={continue|remount-ro|panic}

noquota|quota|usrquota|grpquota

Mount options for msdos¶

See mount options for fat. If the msdos filesystem detects an inconsistency, it reports an error and sets the file system read-only. The filesystem can be made writable again by remounting it.

Mount options for ncpfs¶

Just like nfs, the ncpfs implementation expects a binary argument (a struct ncp_mount_data) to the mount(2) system call. This argument is constructed by ncpmount(8) and the current version of mount (2.12) does not know anything about ncpfs.

Mount options for ntfs¶

iocharset=name

nls=name

utf8

uni_xlate={0|1|2}

posix=[0|1]

uid=value, gid=value and umask=value

Mount options for overlay¶

Since Linux 3.18 the overlay pseudo filesystem implements a union mount for other filesystems.

An overlay filesystem combines two filesystems - an upper filesystem and a lower filesystem. When a name exists in both filesystems, the object in the upper filesystem is visible while the object in the lower filesystem is either hidden or, in the case of directories, merged with the upper object.

The lower filesystem can be any filesystem supported by Linux and does not need to be writable. The lower filesystem can even be another overlayfs. The upper filesystem will normally be writable and if it is it must support the creation of trusted.* extended attributes, and must provide a valid d_type in readdir responses, so NFS is not suitable.

A read-only overlay of two read-only filesystems may use any filesystem type. The options lowerdir and upperdir are combined into a merged directory by using:

mount -t overlay  overlay  \


  -olowerdir=/lower,upperdir=/upper,workdir=/work  /merged

lowerdir=directory

upperdir=directory

workdir=directory

userxattr

redirect_dir={on|off|follow|nofollow}

index={on|off}

uuid={on|off}

nfs_export={on|off}

xino={on|off|auto}

metacopy={on|off}

volatile

Mount options for reiserfs¶

Reiserfs is a journaling filesystem.

conv

hash={rupasov|tea|r5|detect}

hashed_relocation

no_unhashed_relocation

noborder

nolog

notail

replayonly

resize=number

user_xattr

acl

barrier=none / barrier=flush

Mount options for ubifs¶

UBIFS is a flash filesystem which works on top of UBI volumes. Note that atime is not supported and is always turned off.

The device name may be specified as

Alternative ! separator may be used instead of :.

The following mount options are available:

bulk_read

no_bulk_read

chk_data_crc

no_chk_data_crc

compr={none|lzo|zlib}

Mount options for udf¶

UDF is the "Universal Disk Format" filesystem defined by OSTA, the Optical Storage Technology Association, and is often used for DVD-ROM, frequently in the form of a hybrid UDF/ISO-9660 filesystem. It is, however, perfectly usable by itself on disk drives, flash drives and other block devices. See also iso9660.

uid=

gid=

umask=

mode=

dmode=

bs=

unhide

undelete

adinicb

noadinicb

shortad

longad

nostrict

iocharset=

utf8

Mount options for debugging and disaster recovery¶

novrs

session=

anchor=

lastblock=

Unused historical mount options that may be encountered and should be removed¶

uid=ignore

gid=ignore

volume=

partition=

fileset=

rootdir=

Mount options for ufs¶

ufstype=value

onerror=value

Mount options for umsdos¶

See mount options for msdos. The dotsOK option is explicitly killed by umsdos.

Mount options for vfat¶

First of all, the mount options for fat are recognized. The dotsOK option is explicitly killed by vfat. Furthermore, there are

uni_xlate

posix

nonumtail

utf8

shortname=mode

Mount options for usbfs¶

devuid=uid and devgid=gid and devmode=mode

busuid=uid and busgid=gid and busmode=mode

listuid=uid and listgid=gid and listmode=mode