Manage partitions on Linux

Partitioning means dividing a disk into logical sections before creating a file system on it. It is the step that follows identifying the disk and comes before formatting. This guide shows how to choose between MBR and GPT, create a table then partitions with parted, and check the result. All commands were run on an AlmaLinux test disk; the outputs are real.

What you will learn

• Choose between MBR and GPT depending on the hardware
• Create a partition table then partitions with parted
• Check the layout with parted print and lsblk
• Know where fdisk and gdisk remain relevant

Prerequisites

• sudo access and an unmounted disk to prepare (never the system disk)
• Having identified the right disk with lsblk

Why partition

Dividing a disk serves to isolate uses. Separating /home, /var or /data from the root system brings three concrete benefits:

• Isolation: logs filling /var do not stop the root system from working if /var is on its own partition.
• Security: a dedicated partition can receive restrictive mount options in /etc/fstab (noexec, nosuid, nodev), useful on /tmp or /home.
• Targeted backup: back up or restore /home without touching the rest.

In practice, on a modern server, flexibility is often delegated to LVM on top of one or two partitions, rather than to a frozen layout of many partitions.

Partition table: MBR or GPT

Before any partition, the disk needs a partition table, the structure that describes how the disk is divided. Two formats coexist, and the choice is structuring because it is made before everything else.

Feature	MBR (msdos)	GPT
Primary partitions	4 maximum	128 (common usage)
Disk size handled	2 TiB	far beyond
Firmware	Legacy BIOS	UEFI (and BIOS)
Table redundancy	no	yes (backup copy)

Swipe to see more

In 2026, GPT is the default choice: it is required beyond 2 TiB, essential with UEFI (the modern firmware that replaces the BIOS), and more robust thanks to its backup table. Keep MBR only for old systems without UEFI. On GPT with UEFI, a small EFI System Partition (ESP, formatted as FAT32, mounted on /boot/efi, about 512 MiB) holds the boot files.

Create a table and partitions with parted

parted handles MBR as well as GPT and is used on the command line (-s mode to script without interactive confirmation). Start with the table:

sudo parted -s /dev/sda mklabel gpt

Check the target

mklabel erases the existing partition table of the disk. Confirm with lsblk that /dev/sda is really the intended disk (right size, no mount), never the system disk. Review the identification reflex.

Then create the partitions by giving a name, a file system type (only a hint for parted, the real formatting comes later) and the bounds. Here, three partitions: 3 GiB, 2 GiB, then all the rest for LVM:

sudo parted -s /dev/sda mkpart data1 ext4 1MiB 3GiB
sudo parted -s /dev/sda mkpart data2 xfs  3GiB 5GiB
sudo parted -s /dev/sda mkpart lvm        5GiB 100%

The first partition starts at 1 MiB and not at 0: this 1 MiB alignment is the convention that ensures good performance on SSDs and modern arrays. parted applies it automatically.

Check the layout

parted print shows the table created. It is the immediate check after each change:

sudo parted /dev/sda print

Model: QEMU QEMU HARDDISK (scsi)
Disk /dev/sda: 10.7GB
Partition Table: gpt

Number  Start   End     Size    File system  Name   Flags
 1      1049kB  3221MB  3220MB               data1
 2      3221MB  5369MB  2147MB               data2
 3      5369MB  10.7GB  5368MB               lvm

The File system column is empty: the partitions exist but are not formatted yet. lsblk confirms the tree with rounded sizes:

lsblk /dev/sda

NAME   MAJ:MIN RM SIZE RO TYPE MOUNTPOINTS
sda      8:0    0  10G  0 disk
├─sda1   8:1    0   3G  0 part
├─sda2   8:2    0   2G  0 part
└─sda3   8:3    0   5G  0 part

fdisk and gdisk: when to prefer them

parted covers most needs, but two interactive tools keep their place:

• fdisk: the historical editor, now fully GPT compatible. Interactively, n creates a partition, d deletes one, p prints, w writes the changes. Handy for step-by-step exploration. sudo fdisk -l lists all the tables of the system.
• gdisk: a fdisk equivalent specialised in GPT, with fine-grained handling of partition types (GUID codes). Useful for advanced GPT manipulations. Beware, it is not installed on RHEL and AlmaLinux, and is not even in the base repositories: dnf install gdisk answers No match for argument: gdisk, and a search across baseos, appstream, crb and extras returns nothing. The package lives in EPEL, a third-party repository. parted and fdisk are there by default: prefer them if you cannot add a repository.

parted -s is not a blanket yes

The -s (--script) option is often understood as "accept every confirmation". That is wrong: it gives the default answer to each question, which is frequently no.

Measured on AlmaLinux 10 with parted 3.6, when trying to delete a mounted partition:

Warning: Partition /dev/vdb1 is being used. Are you sure you want to continue?

The command exits with rc=1 and the partition is still in the table. A script that assumes the opposite fails while believing it succeeded. So systematically test the exit code, and unmount before acting.

A useful nuance the other way round: adding a partition on a disk whose other partition is mounted works perfectly (mkpart with rc=0, kernel 6.12). Contrary to common belief, it is not the whole disk that is locked, only the partition in use.

To delete a partition with parted, give its number:

sudo parted /dev/sda rm 3

wipefs -a on the disk does not clean the inner signatures

A dormant file system signature can come back to life and make you believe a disk is corrupted. wipefs -a /dev/sdb only erases what it sees at the head of the disk, that is the partition table:

/dev/vdb: 8 bytes were erased at offset 0x00000200 (gpt)
/dev/vdb: 8 bytes were erased at offset 0x27ffffe00 (gpt)
/dev/vdb: 2 bytes were erased at offset 0x000001fe (PMBR)

blkid /dev/vdb then sees nothing anymore, and the disk looks clean. But the XFS signature that was sleeping at the start of the old partition is intact: recreate a partition at the same offset, and it resurfaces at once, with its old UUID.

The right sequence takes two passes, partitions first:

for p in /dev/sdb?*; do sudo wipefs -a "$p"; done
sudo wipefs -a /dev/sdb

Next: format

A partition just created is an empty container. To store data in it, you must format it with a file system (mkfs.ext4, mkfs.xfs...). The choice of file system and the formatting commands are detailed in the dedicated guides, so as not to duplicate them here.

Partitions or LVM?

On a server, you often create a single large LVM partition (like sda3 above) rather than several frozen partitions. LVM then splits this space into logical volumes resizable online, which a partition table does not easily allow.

Put it into practice

Handling parted on a disk that has nothing to lose changes everything: you dare, you make mistakes, you start again. The lab has you put a GPT table on the spare disk, carve two partitions (512 MiB and 1 GiB) with parted, then force the kernel to reread the table to validate the layout.

Guided lab Practice

Learn how to do it

Create GPT partitions on a disk with parted

$ dsoxlab run l2-partition-gpt

Environment: VM·Duration: ~25 min

How it is checked: the state of the system is checked after a reboot, not the command you typed.

First time? What DSOXLab is and how to install it

DSOXLab is the command line that prepares a disposable environment (an isolated shell or a VM), runs the lab scenario, then checks the real state of the system and computes a score. Nothing is installed or broken on your workstation.

It needs Python 3.11 or later, uv or pipx, and git. The installation guide details these prerequisites; on Windows, or on a Mac without Python, use the appliance instead.

This lab starts virtual machines: it also needs ansible-playbook, a hypervisor (KVM or Incus), Terraform and hardware virtualization (/dev/kvm), which inside a VirtualBox VM means nested virtualization. The first time, dsoxlab start l2-partition-gpt checks all of it before creating the machines. Prepare your machine for vm labs.

Install the CLI and add the catalogue, once:

uv tool install dsoxlab   # or: pipx install dsoxlab
dsoxlab catalog add https://github.com/stephrobert/linux-dsoxlab-training

Before you run the lab, check:

• DSOXLab installed
• catalogue available
• compatible environment (isolated shell or VM)

To check, nothing is probed from this page: run dsoxlab doctor. Read the diagnosis

Run this lab, then validate your work:

dsoxlab run l2-partition-gpt
dsoxlab check l2-partition-gpt

See every lab: dsoxlab list-labs. Track your progress: dsoxlab progress. The full dsoxlab guide covers scoring and the pitfalls.

Key points

• A disk needs a partition table before any partition: GPT by default, MBR only for old hardware.
• parted creates the table (mklabel) and the partitions (mkpart) in MBR as in GPT; 1 MiB alignment is automatic.
• parted print and lsblk check the result; an empty File system column flags a partition that is not formatted.
• mklabel erases the table: always confirm the right disk first.
• For flexibility in production, prefer one LVM partition to a frozen layout.
• A partition is only usable once formatted then mounted.

Knowledge check

Check that the essentials of this guide are acquired. The questions only cover what has just been explained here.

Knowledge check

Check what you have learned with this interactive quiz

6 questions

6 min

70% to pass

How it works

• The timer starts when you click Start
• Multiple choice, true/false and short answer questions
• You can move between questions
• Detailed results are shown at the end

Start the quiz

Starts the quiz and the timer

×

See in the glossary →