Updated: 2014-11-14 05:41 EST

1 Introduction to File SystemsIndexup to index

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.

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.

2 The useful file -s commandIndexup to index

The 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.

3 Creating File Systems – Three StepsIndexup to index

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:

  1. Prepare the device (e.g. a disk, USB key, etc.) to receive a file system
    • i.e. partition the device into pieces (Linux fdisk)
  2. Create the file system inside the partition
    • i.e. format or prepare the partition with the chosen file system (Linux mkfs)
    • optionally verify the file system integrity – check for flaws or errors (Linux fsck)
  3. Mount the new file system to make it visible to the users
    • i.e. connect the file system into the existing directory tree (Linux mount)

The trio is always partition, make file system, and mount, in that order. Let’s look at each in more detail:

3.1 Step 1: Create the partition using fdiskIndexup to index

3.2 Step 2: Create the file system in the partition using mkfsIndexup to index

Linux 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.

3.2.1 Syntax: Using mkfs to create a file systemIndexup to index

  • mkfs -t type [other options] device_name
    • common types:   ext3, ext4, vfat
    • use vfat for USB keys, floppy disks, and Microsoft compatibility
    • the device_name is almost always the /dev/ name of an existing partition, not a whole disk
    • e.g.   mkfs -t ext4 /dev/sda1       (first disk, first partition)
    • e.g.   mkfs -t vfat /dev/fd0       (first floppy disk)
  • mke2fs [options] device_name
    • specialized version of mkfs specific to Linux ext2/ext3/ext4 file systems
    • used when you want more control of the details of the file system (RTFM)
  • fsck [options] device_name
    • Optionally, you can check a file system for inconsistencies or errors after creating it using fsck. (Almost never done right after mkfs unless you suspect that your disk may have bad blocks on it.)

3.2.2 Details on using mkfsIndexup to index

  • A file system must be created inside an existing drive/partition
    • You must have an existing partition before you can create a file system.
  • You must have a file system created before you can mount it.
  • The type defaults to the old ext2 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.
  • The 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.)
  • The 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.
  • The 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.)
  • Creating a partition with fdisk does not automatically create any type of file system in that partition.
  • Creating a file system with 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.
  • If file -s can’t find a file system inside a disk partition, you cannot mount it – you probably forgot to make one using mkfs.

3.2.3 Choosing a File System TypeIndexup to index

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.

3.3 Step 3: Mount the file system on an existing directory using mountIndexup to index

Linux File System

Linux File System

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 with mkfs) cannot be mounted. If file -s can’t find a file system inside a disk partition, you cannot mount it – you probably forgot to make one using mkfs.

3.3.1 Manual mount: Use the appropriate mount commandIndexup to index

  • mount
    • Without any options: list all the currently mounted devices and their contained file systems. This is a very common command usage.
  • mount -a
    • Mount all the file systems listed for auto mounting in the /etc/fstab file (possible for root only).
  • mount [options] { device_name | directory_name }
    • Mount the file system in /etc/fstab that matches the given name.
    • You give either the device_name or the directory_name of the entry in the fstab file. The system gets the other one from the fstab.
    • e.g.   mount /dev/sda1       # /etc/fstab will supply the mount point
    • e.g.   mount /home                    # /etc/fstab will supply the partition device name
  • mount [options] device_name directory_name
    • Ignore /etc/fstab and mount the file system inside the given device_name onto the given directory_name mount point.
    • The partition must have a file system created in it (e.g. with mkfs).
    • The directory_name must already exist. (You may need to create it.)
    • e.g.   mount /dev/sda1 /home       # /etc/fstab is not used

3.3.2 Details on using mountIndexup to index

  • Syntax: mount [options] device_name directory_name

  • The device_name is the pathname (usually absolute) of the device containing the file system, e.g. a partition name such as/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.
  • The directory_name is the pathname (often absolute) of an existing Linux directory, usually an empty directory. The file system inside the partition will be mounted on this existing directory mount point. If the mount fails, check to make sure the directory exists! Let me repeat that: If the mount command fails, make sure that the mount point directory exists!
    • Use mkdir to create a new empty directory mount point, if needed.
    • You can “cover up” a non-empty directory by mounting on top of it; this temporarily hides the original contents of the directory and is not usually a good idea.
  • Modern 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.
    • If Linux can’t automatically figure out the type, it usually means the partition has no file system created on it at all – you forgot to use mkfs first. Use file -s to check.
  • You can pass mount-time options using the -o option.
    • the options are the same options you can use in the /etc/fstab file
    • e.g.  mount -o 'ro,noatime' /dev/fd0 /mnt/floppy
  • The user mounting the file system (if not root) must have access rights to the mount point directory and to the mount command.
  • Mounting a file system onto a directory that already contains files will temporarily hide those files until the file system is unmounted again.
  • Examples:
    • 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

3.3.3 Un-mounting a mounted file system: umountIndexup to index

  • You can un-mount a file system using the (badly spelled) Linux umount command and give either the device name or the mount point, but not both:
    • umount /dev/sda1
    • umount /home
  • To un-mount a file system, no files must be open inside it and no programs must have it as a current directory.
  • If the message “device is busy” appears, a process is currently accessing the device.
  • A common mistake is to try (and fail) to unmount the file system of the current directory – you have to cd all your shells and processes out of the file system first.
  • Sometimes you have to find and kill processes that are using a file system as a current directory, so that you can unmount the file system.
  • Commands to list files open on a file system (use these as root, and give the Linux directory that is the root of the file system):
    • fuser /boot
    • lsof /

3.3.4 Running a File System Check with fsckIndexup to index

  • If the system reboots and ends up in “repair file system” mode, all the file systems will be mounted “read only” so that you can repair them.
  • If you need to edit/modify/change any files (/etc/fstab for example) you will need to “re-mount” that file system as read-write.
  • To switch /dev/sda1 to read-write mode use the “remount” option:
    • mount –o remount,rw /dev/sda1

3.3.5 Using mount and the /etc/fstab fileIndexup to index

To 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:

  • e.g.   mount /dev/sda2 /home
  • e.g.   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:

  • e.g.   mount /dev/sda1       # gets the directory name and options from /etc/fstab
  • e.g.   mount /home                 # gets the device name and options from /etc/fstab

3.3.6 Example of an /etc/fstab fileIndexup to index

Lines 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:

  1. Field 1: Identifies the device (partition) to be mounted
    • traditionally, this a partition name under /dev/ containing a file system, e.g. /dev/sda1
    • can be a LABEL or a UUID: Above, both ROOT / and swap are mounted by UUID instead of by device name
    • we mount file systems by partition name, but the partition really does have to have a file system created inside it for the mount to work, and the type field has to match the file system that is in the partition
  2. Field 2: Names the existing mount point directory where that device is to be mounted
    • this directory is called the mount point and must already exist
    • usually, the directory should be empty (but it doesn’t have to be)
      • you can “cover up” a non-empty directory by mounting on top of it; not usually a good idea
  3. Field 3: Names the type of file system inside the partition being mounted
    • modern Unix/Linux systems can figure this out automatically for most types of file systems if you use the keyword auto here
    • auto is the best idea, since if you’re wrong about the type, the system won’t boot properly
    • many types in fstab 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
  4. Field 4: Optional mount options as a comma-separated list (no spaces!)
    • useful options (see below): noauto, user
    • the keyword defaults uses some default options that depend on the file system type – RTFM
  5. Field 5: Which file systems to back up
    • A non-zero value indicates backup priority/order
    • A zero means “don’t back up this file system”
  6. Field 6: The order in which file system checks are done at boot time
    • The fsck program uses this to run file system checks in order
    • The root should always be checked first – value 1
    • Use value 2 or larger for any others that need to be checked
    • No value or a value of 0 means no file system check

File 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

3.3.7 Some common options in fstab used by mountIndexup to index

  • auto – 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 system
  • nouser – only root can mount and unmount this file system (default)
  • defaults – use default options:   auto, exec, rw, nouser
    • Defaults may vary with distribution! Be careful!

4 Virtual Memory – Swap PartitionsIndexup to index

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

4.1 Step 1: Create the partition using fdiskIndexup to index

4.2 Step 2: Initialize (format) the swap area using mkswapIndexup to index

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:

4.3 Step 3: Connect the swap area to the system using swaponIndexup to index

| Ian! D. Allen  -  idallen@idallen.ca  -  Ottawa, Ontario, Canada
| Home Page: http://idallen.com/   Contact Improv: http://contactimprov.ca/
| College professor (Free/Libre GNU+Linux) at: http://teaching.idallen.com/
| Defend digital freedom:  http://eff.org/  and have fun:  http://fools.ca/

Plain Text - plain text version of this page in Pandoc Markdown format

Campaign for non-browser-specific HTML   Valid XHTML 1.0 Transitional   Valid CSS!   Creative Commons by nc sa 3.0   Hacker Ideals Emblem   Author Ian! D. Allen