# LPI Linux Certification/Create Partitions And Filesystems
## Detailed Objectives

(LPIC-1 Version 5.0)
Weight: 2
Description: Candidates should be able to configure disk partitions and then create filesystems on media such as hard disks. This includes the handling of swap partitions.
Key Knowledge Areas:
* Manage MBR and GPT partition tables
* Use various mkfs commands to set up partitions and create various filesystems such as:
** ext2/ext3/ext4
** XFS
** VFAT
** exFAT
* Basic feature knowledge of Btrfs, including multi-device filesystems, compression and subvolumes.
The following is a partial list of the used files, terms and utilities:
* fdisk
* gdisk
* parted
* mkfs
* mkswap

## Partitions

Media can be divided into partitions. Partitions are usually created at installation time but can also be created with the fdisk program or other utilities. This will divide the media into partitions where different filesystems can be built and different operating systems can be installed.
IDE is recognized as follows:
* Primary Master:
       /dev/hda : Full disk
       /dev/hda1: First partition
       /dev/hda2: Second partition
* Primary Slave: /dev/hdb
* Secondary Master: /dev/hdc
* Secondary Slave: /dev/hdd
SCSI is recognized as follows:
* ID1:
       /dev/sda: Full disk
       /dev/sda1: First partition
* ID2: /dev/sdb
The Personal computer systems does not support more than four primary partitions, to overcome this limitation, the concept of extended partitions are used.
* Hard Disk
       /dev/sda1 : First primary
       /dev/sda2 : Second Primary
       /dev/sda3 : Third Primary
       /dev/sda4 : Extended Partition
             /dev/sda5 : First extended/Logical
             /dev/sda6 : Second extended/Logical
USB and FireWire disks are recognized as SCSI disks.
Once it is partitioned it is possible to build a filesystem on every partition.

## Filesystems

Filesystems exist to allow you to store, retrieve and manipulate data on a medium. Filesystems maintain an internal data structure (meta-data) that keeps all of your data organized and accessible. The structure of this meta-data imparts the characteristics of the filesystem. A filesystem is accessed by a driver through the organized meta-data structure. When Linux boots it reads in /etc/fstab all the filesystems that need to be mounted and checks if they are in a usable state.
When a power failure occurs Linux won't be able to unmount the filesystem properly and some data in the cache won't be synchronized on the media.
As such, the meta-data may be corrupted.
Once you reboot the system, it will detect this and do a fsck to the full meta-data structure for a consistency check. This can take a very long time. Few minutes to few hours in proportion of the media size. Journaling a filesystem is adding a new data structure called a journal. This journal is on-disk and before each modification to the meta-data is made by the driver it is first written into the journal. Before each meta-data modification the journal maintains a log of the next operation.
Now, when a power failure occurs there is only the need to check the journal. A journaling filesystem recovery is very fast. It just needs to go through the logs and fix the latest operation. Journaling filesystem recovery can take only few seconds.
On a cluster systems, journaling allows to quickly recover a shared partition of a node that went down.

## Linux filesystems

* ext2: Old very stable Linux filesystem. Efficient for files larger than ~2-3K.
* ext3: Journaling extension for ext2. Possible to move a filesystem back and forth between ext2 and ext3.
* Reiserfs: Journaling filesystem. 8-15 time faster than ext2 when manipulating small files.
* XFS: A powerful journaling filesystem with possible quota and ACL
* Msdos: MS-Windows FAT filesystem type. (mainly used for floppy)
* Vfat: MS-Windows FAT filesystem type. (mainly used for large hdd partitions)
* NTFS (ReadOnly but loop files): MS-Windows journaling filesystem
* SMBFS: A filesystem to mount windows or samba sharing from Linux
* NFS: Network File System

## Filesystem tree

A Linux file system has one top directory called root (/) where all sub directories of the entire system is stored. The sub directories can be another partition, a remote directory, or a remote partition accessible through the network with NFS protocol.

## Create filesystems

To create a file system on a partition, use mkfs.
Common options:
    -t: fstype: File system type.
    -c : Check the device for bad blocks before building the filesystem.
The full partition will be ereased and organized to the type of filesystem requested. There is no undo command. The fstype possible are: msdos, ext2, ext3, reiserfs,minix,xfs
The blocksize allows to customize the block size for your filesystem.
Examples:

## Create extended filesystems

To create an extended (ext2, ext3) filesystem on an partition, use mke2fs.
Common options:
    -b: Specify the block sizefstype: File system type.
    -c : Check the device for bad blocks before building the filesystem.
    -j: Create the filesystem with an ext3 journal.
    -L: Set the volume label for the filesystem.
With mke2fs it is possible to store the super-block the journal information on another device. Examples:

## Monitoring disk usage

To print the disk usage, use du.
Common options:
    -a: All files not just directories
    -b: Print size in bytes
    -c: Total
    -h: Human readable format. (1K, 20M,...)
Examples:

## Filesystem disk space

A filesystem is composed of a meta-data structure plus a list of blocks. To print the filesystem disk space usage, use df.
Common options:
    -a: All included filesystems with 0 blocks.
    -t: Limit listing to a filesystem type.
    -h: Human readable format. (1K, 20M,...)
    -i: List inode information instead of block usage
Examples:

## Exercises

* Exercises results