Updated: 2014-11-14 05:41 EST
file -s
commandfdisk
mkfs
mount
commandmount
umount
fsck
mount
and the /etc/fstab
file/etc/fstab
filefstab
used by mount
Creating a partition using fdisk
simply divides up the space on a disk. It doesn’t by itself allow the operating system to store files there. You first have to create some infrastructure to hold content inside the partition; you have to create a File System inside the partition.
A File System is a way of storing content inside a disk partition. There are many kinds of file systems, each with different characteristics. Linux supports a huge number. Proprietary operating systems generally only support their own types of file systems. (Linux can access Linux, Apple, and Microsoft file systems, and dozens of others. Apple can only access Apple and Microsoft file systems. Microsoft can only access Microsoft file systems – “Does not play well with others.”)
A file system is the way the O/S stores and retrieves data inside the partition, e.g.
touch cp mkdir rmdir
)ln, rm, mv
)vi, cat, head, tail, sort
)find
)grep
)ls
)The above basic functions are common to most operating systems, but they are implemented and managed differently from one O/S to another and perhaps even from one kind of file system to another.
file -s
commandIndexThe Unix/Linux file
command is very useful for identifying things in the file system, such as directories, programs, images, files, and special files such as disk partitions. The -s
option is useful for finding out what kind of file system (if any) is inside a disk partition:
# file /dev/sda1
/dev/sda1: block special
# file -s /dev/sda1
/dev/sda1: Linux rev 1.0 ext4 filesystem data (needs journal recovery) (extents) (large files) (huge files)
# file -s /dev/sda2
/dev/sda2: Linux/i386 swap file (new style) 1 (4K pages) size 140031 pages
# file -s /dev/sda
/dev/sda: x86 boot sector; GRand Unified Bootloader, stage1 version 0x3, boot drive 0x80, 1st sector stage2 0x11cb38, GRUB version 0.94; partition 1: ID=0x83, active, starthead 32, startsector 2048, 3072000 sectors; partition 2: ID=0x82, starthead 89, startsector 3074048, 1120256 sectors, code offset 0x48
If file -s
doesn’t show a valid file system inside a disk partition, then you can’t mount
the file system.
The three steps to create a file system don’t change much from one operating system to another, but the specific details and utilities used vary greatly. The steps are:
fdisk
)mkfs
)fsck
)mount
)The trio is always partition, make file system, and mount, in that order. Let’s look at each in more detail:
fdisk
Indexfdisk
, Disk Druid or any other partitioning tool that can manage and create Linux partitionsfdisk
: see http://tldp.org/HOWTO/Partition/fdisk_partitioning.htmlmkfs
IndexLinux organizes data inside partitions using various types of file systems. Linux supports a large number of different file system types, including most of the Windows file system types. You can use mkfs
to create a file system to optimize the way data being stored in a partition. The mkfs
command is actually a front-end for a whole set of mkfs
commands, each different one selected by the -t
option to mkfs
.
mkfs
to create a file systemIndexmkfs -t
type [other options] device_name
ext3
, ext4
, vfat
vfat
for USB keys, floppy disks, and Microsoft compatibility/dev/
name of an existing partition, not a whole diskmkfs -t ext4 /dev/sda1
(first disk, first partition)mkfs -t vfat /dev/fd0
(first floppy disk)mke2fs
[options] device_name
mkfs
specific to Linux ext2/ext3/ext4
file systemsfsck
[options] device_name
fsck
. (Almost never done right after mkfs
unless you suspect that your disk may have bad blocks on it.)mkfs
Indexext2
type, but for modern Linux hard disk systems you should always specify the type explicitly as either ext3
or ext4
. These newer file system types are journalling file systems. Do not use the old default ext2
file system type, especially on large (over 400MB) disks.device_name
is the pathname (usually absolute) of the existing device or partition that will be used, usually of the form /dev/sdXN
, where X is the letter of the device (disk) being used and N is the partition number on that device. (Recall that partitions are created using the fdisk
command.)mkfs
commands do not check to see what is in the partition already. They will not ask “Are You Sure?” before they re-format a partition and destroy whatever was previously there. Be extremely careful to get the device name correct! A partition destroyed by mkfs
is impossible to recover.mkfs
commands do not care about the System ID (type) of a partition given in the partition table. You can create any type of file system in any type of partition. (For example, you can create an ext4
file system on a partition labelled in the partition table as NTFS or as Swap, but this is a bad idea.)fdisk
does not automatically create any type of file system in that partition.mkfs
does not automatically mount or make available that file system for use in Linux. The new file system is not accessible. More on mounting file systems in the next section.file -s
can’t find a file system inside a disk partition, you cannot mount
it – you probably forgot to make one using mkfs
.Your system install likely created “journalling” file systems on your virtual disk, using the -t ext4
option to mkfs
. Another way to request this kind of file system is to use the -j
(Journalling) option to the original mke2fs
command. This type of Linux journalling file system is usually called ext3
or ext4
, and some distributions may have a small shell script named mke3fs
or mke4fs
that simply calls mke2fs
with the appropriate -t
or -j
option.
Journalling file systems are more resistant to corruption due to sudden power loss, allowing the system to come back up more quickly by avoiding a long file system check at boot time. This does NOT give you permission to power off a running Linux system! Always shut down cleanly. The correct command-line for an immediate, safe system shut down is:
# shutdown -h now # shut down and halt (usually power off)
# shutdown -r now # shut down and then reboot
See the man page for other options.
Unlike Windows with its multiple drive letters, Linux has a single-ROOTed file system tree. “Mounting” attaches an existing file system found on a block device (usually a disk partition, e.g. /dev/hda2
or /dev/sda2
) to the Linux directory structure, e.g. onto some directory /boot
. Accessing that directory, and everything under that directory, accesses the file system on that disk partition.
Any number of separate file systems (stored in disk partitions) can be attached anywhere in the same Linux directory tree, resulting in one single ROOTed tree to access every file on every disk. You can detach a file system from one place in the tree and attach it somewhere else, but then the pathnames to files inside that file system would change to reflect the new mount location.
File systems can be mounted from the Unix/Linux command line using the mount
command. File systems can be mounted automatically at system boot time by putting their names and mount points into the /etc/fstab
file. File systems on removable devices (USB keys, DVDs) can also be mounted dynamically at device insertion time using rules in system configuration files (“automounting”).
(Most distribution use an existing /mnt/
directory to attach file systems dynamically and temporarily to the directory structure, e.g. USB keys, CDROM and DVD, floppy disks, etc.) Desktop operating systems may also use a /media/
directory for dynamic storage devices.
You can only mount file systems, not partitions. An empty partition (one created with
fdisk
but not initialized withmkfs
) cannot be mounted. Iffile -s
can’t find a file system inside a disk partition, you cannotmount
it – you probably forgot to make one usingmkfs
.
mount
commandIndexmount
mount -a
auto
mounting in the /etc/fstab
file (possible for root
only).mount
[options] { device_name | directory_name }
/etc/fstab
that matches the given name.fstab
file. The system gets the other one from the fstab
.mount /dev/sda1
# /etc/fstab
will supply the mount pointmount /home
# /etc/fstab
will supply the partition device namemount
[options] device_name directory_name
/etc/fstab
and mount the file system inside the given device_name onto the given directory_name mount point.mkfs
).mount /dev/sda1 /home
# /etc/fstab
is not usedmount
IndexSyntax: mount
[options] device_name directory_name
/dev/sdb9
. The device is usually a partition name, not a disk name. The partition must have a recognized file system created inside it already, because you are mounting the file system that is inside the partition, not the partition itself.mkdir
to create a new empty directory mount point, if needed.mount
commands are smart enough to know what type of file system resides inside a partition, but rarely you may have to specify the type of file system in the partition using the -t
option.
mkfs
first. Use file -s
to check.-o
option.
/etc/fstab
filemount -o 'ro,noatime' /dev/fd0 /mnt/floppy
root
) must have access rights to the mount point directory and to the mount
command.mkdir /mnt/foo ; mount /dev/sda1 /mnt/foo
mkdir /mnt/dosfloppy ; mount -t vfat /dev/fd0 /mnt/dosfloppy
mkdir /mnt/foobar ; mount /dev/sdb9 /mnt/foobar
umount
Indexumount
command and give either the device name or the mount point, but not both:
umount /dev/sda1
umount /home
cd
all your shells and processes out of the file system first.fuser /boot
lsof /
fsck
Index/etc/fstab
for example) you will need to “re-mount” that file system as read-write./dev/sda1
to read-write mode use the “remount” option:
mount –o remount,rw /dev/sda1
mount
and the /etc/fstab
fileIndexTo ensure that a file system is mounted at every boot, add the file system to the /etc/fstab
file and it will always be mounted at boot time. To learn about the format of this file: man 5 fstab
File systems can be listed in the /etc/fstab
file to automate the mounting process. Both the mount point (the existing directory on which the file system is to be mounted) and any other options can be stored in the fstab
file.
The file systems can be identified in fstab
in the traditional way by partition name (e.g. /dev/sda1
), which is a bit risky since disk names can change depending on what is attached to your machine at boot time. Another way to identify file systems is with a Volume Label or UUID (Unique UID) identifier that is configured into the partition and that doesn’t change even if the partition name changes. You can see these Labels and UUIDs using the blkid
command. You can set Labels and UUIDs into a partition using the tune2fs
command.
If a file system is not listed in the /etc/fstab
file and you wish to mount it, then all mount information about the file system and all options need to be given on the command line. At minimum, you need the device name (partition) and the existing mount point (directory) where the file system should be mounted:
mount /dev/sda2 /home
mount -o 'ro' /dev/sda2 /home_readonly
If a file system is listed in the /etc/fstab
file, then indicating either just the mount point (the directory name) or just the device name (e.g. /dev/sda1
) will indicate to the mount
command that the rest of the information needed for the mount should be copied from the matching entry in the /etc/fstab
file:
mount /dev/sda1
# gets the directory name and options from /etc/fstab
mount /home
# gets the device name and options from /etc/fstab
/etc/fstab
fileIndexLines in /etc/fstab
starting with #
are comments and are ignored:
# Sample /etc/fstab taken from Linux installed with two disk partitions
# 1 2 3 4 5 6
# DEVICE MOUNT POINT TYPE OPTIONS BACKUP FSCK
UUID=dd2e3867-0f87-4fe9-9195-d60ad7b28897 / ext4 defaults 1 1
UUID=16dfd36c-7422-43ac-89eb-5132488274d7 swap swap defaults 0 0
tmpfs /dev/shm tmpfs defaults 0 0
devpts /dev/pts devpts gid=5,mode=620 0 0
sysfs /sys sysfs defaults 0 0
proc /proc proc defaults 0 0
# 1 2 3 4 5 6
Each line in /etc/fstab
has six fields that describes a file system:
/dev/
containing a file system, e.g. /dev/sda1
/
and swap are mounted by UUID instead of by device nameauto
hereauto
is the best idea, since if you’re wrong about the type, the system won’t boot properlyfstab
refer to pseudo-file-systems that don’t have real device names, e.g. tmpfs
, devpts
, sysfs
, proc
, and sometimes the device name is given as simply none
noauto
, user
defaults
uses some default options that depend on the file system type – RTFMfsck
program uses this to run file system checks in orderFile systems do not need to be listed in the /etc/fstab
file to be mounted – you can always mount anything manually from the command line. The fstab
is just for things that you want mounted when the system boots.
Having a file system listed in the fstab
means you only need to specify the device
name or the mount point
to the mount
command; the other information for the mount will be read from the /etc/fstab
file:
# grep foo /etc/fstab
/dev/sdb1 /mnt/foo ext4 defaults,noauto 1 2
# mount /dev/sdb1 # system gets /mnt/foo mount point from fstab
*** OR ***
# mount /mnt/foo # system gets /dev/sdb1 device from fstab
*** OR ***
# mount /dev/sdb1 /mnt/bar # ignore fstab and do explicit mount
fstab
used by mount
Indexauto
– will be mounted when mount
is used with the -a option (and so mounted at boot time) (default)noauto
– will be ignored by the -a option (not mounted at boot time)exec
– permit execution of binaries (default)ro
– mount the file system read-only (read, execute, no writing)rw
– mount the file system read-write (default)user
– let a non-root user mount and unmount this file systemnouser
– only root can mount and unmount this file system (default)defaults
– use default options: auto, exec, rw, nouser
Another use for disk partitions is to hold memory pages used to implement Unix/Linux Virtual Memory. These are called swap
partitions or the swap area, and they, too need some minimal structure created to be used by the system. Usually, you find only one swap partition in a system, but systems with a lot of memory may have more.
Again, there are the usual three steps: Partition, Create, and Connect
fdisk
Indexfdisk
Linux Swap
to document that this is a swap partition. Many systems will automatically connect and use swap partitions if they have the correct type ID.mkswap
Indexmkswap [options] device_name
mkswap /dev/sdb9
The device_name
is the pathname (usually absolute) of the existing swap partition that will be used. These commands do not care about the System ID (type) of a partition given in the partition table. You can initialize as swap any type of partition. Most Linux systems at boot time will automatically use as swap all partitions that have a type of “Linux swap”, if they are initialized as swap. You can add more swap space to a running system using the above two commands.
To display the currently active swap partitions, omit the device_name
and use only the -s
or --summary
option to the swapon
command:
swapon -s
swapon
Indexswapon
to activate the swap area you just created with mkswap
swapon device_name
swapon /dev/sdb9
swapon -s
(list all currently active swap areas)swapoff
to de-activate (stop using) a swap area:
swapoff device_name
swapoff /dev/sdb9
-a
option will disconnect all swap areas (not usually a good idea)/etc/fstab
marked with type swap
will be automatically connected and used as swap areasfstab
swap partitions be connected using:
swapon -a
(connect and enable all known swap partitions)swapoff
command has an identical option to disconnect all active swap areas