Intermediate 19 min read Sep 13, 2025 Tutorial

Linux Guide

Linux Disk Partitioning: Complete fdisk and parted Guide Linux Mastery Series

Start Reading

Table of Contents 0%

Reading Progress 0%

luc

Guide Author

Last updated: Sep 13, 2025 4312 words

How can I manage disk partitions effectively on Linux systems?

Quick Answer: Master Linux disk partitioning by understanding that fdisk provides interactive MBR and GPT partition management, parted offers command-line flexibility for both partition schemes, and lsblk displays current disk layouts. Furthermore, effective disk partitioning enables organized storage allocation, multiple file systems, and optimized system performance through proper space management.

# Essential Linux disk partitioning commands for storage management
lsblk                              # List all block devices and partitions
fdisk -l                           # Display all disk partition tables
parted -l                          # Show partition information for all disks
fdisk /dev/sdX                     # Interactive partitioning with fdisk
parted /dev/sdX                    # Interactive partitioning with parted
gdisk /dev/sdX                     # GPT partitioning with gdisk
partprobe                          # Update kernel partition table
blkid                              # Display partition UUIDs and types

What Is Linux Disk Partitioning and Why Is It Essential?
How to Understand MBR vs GPT Partition Tables?
How to Use fdisk for Interactive Disk Partitioning?
How to Use parted for Flexible Storage Management?
How to Use gdisk for GPT Disk Partitioning?
How to View and Analyze Storage Partitions?
How to Create Advanced Linux Partitioning Schemes?
How to Manage Partition Recovery and Backup?
Frequently Asked Questions
Common Issues and Troubleshooting

What Is Linux Disk Partitioning and Why Is It Essential?

Disk partitioning is the fundamental process of dividing a physical storage device into logical sections called partitions, each functioning as an independent storage unit. Additionally, partitioning enables multiple file systems, organized data separation, performance optimization, and enhanced security through isolated storage compartments on a single physical disk.

Core Linux Disk Partitioning Benefits:

Data organization: Separate system, user, and application data
Multiple file systems: Different partitions can use different file systems
Performance optimization: Dedicated partitions for specific workloads
Security isolation: Separate partitions limit damage from corruption
Backup efficiency: Selective backup of specific partitions

# Understanding disk and partition hierarchy
# View all storage devices and partitions
lsblk                              # Tree view of block devices
lsblk -f                           # Include file system information
lsblk -p                           # Show full device paths

# Display detailed partition information
fdisk -l                           # List all partition tables
parted -l                          # Alternative detailed listing
cat /proc/partitions               # Kernel's partition table view

# Check disk space usage
df -h                              # Human-readable disk usage
df -T                              # Include file system types
du -sh /*                          # Directory space usage

# Example output interpretation
# sda                    8:0    0  100G  0 disk
# ├─sda1                 8:1    0   512M  0 part /boot/efi
# ├─sda2                 8:2    0     1G  0 part /boot
# └─sda3                 8:3    0  98.5G  0 part
#   ├─ubuntu--vg-root  253:0    0   97.5G  0 lvm  /
#   └─ubuntu--vg-swap  253:1    0    1G  0 lvm  [SWAP]

Moreover, proper Linux disk partitioning is essential for system stability, data integrity, and enables advanced storage features like logical volume management (LVM) and RAID configurations as outlined in the Red Hat Storage Guide{target=”_blank”}.

How to Understand MBR vs GPT Partition Tables?

Master Boot Record (MBR) and GUID Partition Table (GPT) are two different partition table standards with distinct capabilities and limitations. Furthermore, understanding their differences is crucial for choosing the appropriate Linux disk partitioning scheme based on disk size, system requirements, and compatibility needs.

MBR Partition Table Characteristics

Feature	MBR Specification	Limitation
Maximum disk size	2TB	Cannot address larger disks
Maximum partitions	4 primary partitions	Extended partitions needed for more
Boot record location	First 512 bytes	Single point of failure
System compatibility	Legacy BIOS systems	Limited modern system support

# MBR (Master Boot Record) specifications:
# - Maximum disk size: 2TB
# - Maximum partitions: 4 primary partitions
# - Extended partitions: Can contain logical partitions
# - Boot record: Located in first 512 bytes
# - Compatibility: Legacy BIOS systems
# - Partition types: Primary, Extended, Logical

# View MBR partition table
fdisk -l /dev/sdX                  # Display MBR partition information
parted /dev/sdX print              # Alternative MBR viewing

# Example MBR partition layout
# Device     Boot   Start      End  Sectors  Size Id Type
# /dev/sda1  *       2048  1026047  1024000  500M 83 Linux
# /dev/sda2       1026048  3074047  2048000    1G 82 Linux swap
# /dev/sda3       3074048 20971519 17897472  8.5G 83 Linux
# /dev/sda4      20971520 41943039 20971520   10G  5 Extended
# /dev/sda5      20973568 25167871  4194304    2G 83 Linux

# MBR partition types (System ID)
# 83 = Linux filesystem
# 82 = Linux swap
# 8e = Linux LVM
# fd = Linux RAID autodetect
# 05 = Extended partition

GPT Partition Table Features

Feature	GPT Specification	Advantage
Maximum disk size	9.4 ZB (zettabytes)	Handles massive storage
Maximum partitions	128 partitions (standard)	No extended/logical distinction
Redundancy	Backup partition table at disk end	Enhanced reliability
System compatibility	UEFI systems, BIOS with hybrid MBR	Modern system support

# GPT (GUID Partition Table) specifications:
# - Maximum disk size: 9.4 ZB (zettabytes)
# - Maximum partitions: 128 partitions (standard)
# - No extended/logical distinction: All partitions are primary
# - Redundancy: Backup partition table at disk end
# - Compatibility: UEFI systems, BIOS with hybrid MBR
# - Unique identifiers: Each partition has a GUID

# View GPT partition table
gdisk -l /dev/sdX                  # Display GPT information
parted /dev/sdX print              # Show GPT details
sgdisk -p /dev/sdX                 # Alternative GPT listing

# Example GPT partition layout
# Number  Start (sector)    End (sector)  Size       Code  Name
#    1            2048         1050623   512.0 MiB   EF00  EFI System
#    2         1050624         2099199   512.0 MiB   8300  Linux filesystem
#    3         2099200        20971519     9.0 GiB   8300  Linux filesystem
#    4        20971520        41943039    10.0 GiB   8e00  Linux LVM

# GPT partition type codes
# EF00 = EFI System Partition
# 8300 = Linux filesystem
# 8200 = Linux swap
# 8e00 = Linux LVM
# fd00 = Linux RAID

Choosing Between MBR and GPT for Linux Disk Partitioning

# Decision criteria for partition table selection
# Use MBR when:
# - Disk size is less than 2TB
# - Legacy BIOS system compatibility required
# - Maximum 4 partitions sufficient
# - Older operating system support needed

# Use GPT when:
# - Disk size exceeds 2TB
# - UEFI system available
# - More than 4 partitions needed
# - Enhanced reliability required (backup partition table)
# - Modern system with advanced features

# Check current system boot mode
[ -d /sys/firmware/efi ] && echo "UEFI" || echo "BIOS"
ls /sys/firmware/efi/efivars 2>/dev/null && echo "UEFI system" || echo "BIOS system"

# Convert between MBR and GPT (DANGEROUS - backup first!)
# Convert MBR to GPT (non-destructive if space available)
gdisk /dev/sdX
# Use 'w' command to write GPT, keeping existing partitions

# Convert GPT to MBR (may lose partitions beyond 4)
sgdisk -m /dev/sdX                 # Convert GPT to MBR

Consequently, modern Linux systems benefit from GPT’s advanced features as detailed in the UEFI Specification{target=”_blank”}.

How to Use fdisk for Interactive Disk Partitioning?

fdisk is the traditional Linux disk partitioning tool providing an interactive interface for creating, modifying, and deleting disk partitions. Additionally, fdisk supports both MBR and GPT partition tables with a command-driven interface that allows review before committing changes to disk.

Basic fdisk Operations

# Starting fdisk for interactive partitioning
fdisk /dev/sdX                     # Start fdisk on specific device
fdisk -l                           # List all partition tables
fdisk -l /dev/sdX                  # List specific device partitions

# Essential fdisk commands (within fdisk interface)
# m    - Display help menu
# p    - Print current partition table
# n    - Create new partition
# d    - Delete partition
# t    - Change partition type
# a    - Toggle bootable flag
# w    - Write changes and exit
# q    - Quit without saving changes

# Example fdisk session for new disk
sudo fdisk /dev/sdb
# Command (m for help): n          # Create new partition
# Partition type: p                # Primary partition
# Partition number (1-4): 1        # First partition
# First sector: <Enter>            # Use default
# Last sector: +10G                # 10GB partition
# Command (m for help): p          # Preview changes
# Command (m for help): w          # Write and exit

Creating Different Partition Types

# Creating primary partitions with fdisk
sudo fdisk /dev/sdb << EOF
n      # New partition
p      # Primary partition
1      # Partition number 1
       # Default first sector
+10G   # 10GB size
n      # New partition
p      # Primary partition
2      # Partition number 2
       # Default first sector
+5G    # 5GB size
w      # Write changes
EOF

# Creating extended and logical partitions
sudo fdisk /dev/sdb << EOF
n      # New partition
e      # Extended partition
3      # Partition number 3
       # Default first sector
       # Use remaining space
n      # New partition
       # Logical partition (automatic in extended)
       # Default first sector
+2G    # 2GB logical partition
w      # Write changes
EOF

# Setting partition types
sudo fdisk /dev/sdb << EOF
t      # Change partition type
2      # Partition number 2
82     # Linux swap type
t      # Change partition type
1      # Partition number 1
83     # Linux filesystem type
w      # Write changes
EOF

Notably, fdisk’s interactive nature makes it ideal for learning Linux disk partitioning fundamentals as documented in the Linux Documentation Project{target=”_blank”}.

How to Use parted for Flexible Storage Management?

parted is a powerful partition editor that supports both MBR and GPT partition tables with both interactive and command-line modes. Furthermore, parted provides advanced features like partition resizing, precise size specifications, and optimal alignment for modern storage devices.

Basic parted Operations

# Starting parted for partition management
parted /dev/sdX                    # Interactive mode
parted /dev/sdX print              # Display partition table
parted -l                          # List all disk partition tables
parted -s /dev/sdX command         # Script mode (non-interactive)

# Essential parted commands
# (parted) help                    # Show available commands
# (parted) print                   # Display current partitions
# (parted) mklabel gpt              # Create GPT partition table
# (parted) mklabel msdos            # Create MBR partition table
# (parted) mkpart primary 0% 50%   # Create partition using percentages
# (parted) rm 1                    # Remove partition 1
# (parted) resizepart 1 100%       # Resize partition 1
# (parted) quit                    # Exit parted

# Example interactive parted session
sudo parted /dev/sdb
# (parted) mklabel gpt             # Create GPT partition table
# (parted) mkpart primary 0% 25%   # First partition (25% of disk)
# (parted) mkpart primary 25% 50%  # Second partition
# (parted) mkpart primary 50% 75%  # Third partition
# (parted) mkpart primary 75% 100% # Fourth partition
# (parted) print                   # Verify partitions
# (parted) quit                    # Exit and save

Advanced parted Features

Parted Feature	Command Example	Benefit
Percentage sizing	`mkpart primary 0% 50%`	Flexible disk utilization
Optimal alignment	`parted -a optimal`	SSD performance optimization
Online resizing	`resizepart 1 100%`	Live partition expansion
Unit flexibility	`unit MiB`	Precise size specifications

# Creating partitions with specific sizes and alignment
# Optimal alignment for SSDs and modern drives
parted -a optimal /dev/sdb mklabel gpt

# Create partitions with specific sizes
parted -s /dev/sdb mkpart primary 1MiB 512MiB      # 511MB partition
parted -s /dev/sdb mkpart primary 512MiB 1024MiB   # 512MB partition
parted -s /dev/sdb mkpart primary 1024MiB 100%     # Remaining space

# Set partition flags
parted -s /dev/sdb set 1 boot on           # Set boot flag
parted -s /dev/sdb set 2 swap on           # Set swap flag
parted -s /dev/sdb set 3 lvm on            # Set LVM flag

# Using different units for precision
parted /dev/sdb unit MiB print             # Display in MiB
parted /dev/sdb unit % print               # Display in percentages
parted /dev/sdb unit s print               # Display in sectors

Consequently, parted excels at Linux disk partitioning automation as detailed in the GNU Parted Manual{target=”_blank”}.

How to Use gdisk for GPT Disk Partitioning?

gdisk is a specialized partitioning tool designed specifically for GPT (GUID Partition Table) management, offering advanced GPT features and compatibility with large disks. Additionally, gdisk provides detailed control over GPT-specific attributes, partition alignment, and GUID management while maintaining familiarity for fdisk users.

Basic gdisk Operations

# Starting gdisk for GPT partition management
gdisk /dev/sdX                     # Interactive GPT partitioning
gdisk -l /dev/sdX                  # List GPT partition table
sgdisk -p /dev/sdX                 # Script-friendly GPT listing

# Essential gdisk commands (similar to fdisk)
# ?    - Help menu
# p    - Print partition table
# n    - Create new partition
# d    - Delete partition
# t    - Change partition type code
# x    - Enter expert menu
# w    - Write table to disk and exit
# q    - Quit without saving

# Example gdisk session
sudo gdisk /dev/sdb
# Command (? for help): n          # New partition
# Partition number (1-128): 1      # Partition number
# First sector: <Enter>            # Default first sector
# Last sector: +10G                # 10GB partition
# Hex code or GUID: 8300           # Linux filesystem
# Command (? for help): p          # Print table
# Command (? for help): w          # Write and exit

GPT-Specific Features with gdisk

# Working with GPT partition type codes
# Common GPT partition types:
# EF00 = EFI System Partition
# 8300 = Linux filesystem
# 8200 = Linux swap
# 8e00 = Linux LVM
# fd00 = Linux RAID
# 0700 = Microsoft basic data

# Creating specific partition types
sudo gdisk /dev/sdb << EOF
n      # New partition
1      # Partition number
       # Default first sector
+512M  # 512MB EFI partition
EF00   # EFI System Partition type
n      # New partition
2      # Partition number
       # Default first sector
+2G    # 2GB swap partition
8200   # Linux swap type
n      # New partition
3      # Partition number
       # Default first sector
       # Use remaining space
8300   # Linux filesystem type
w      # Write changes
y      # Confirm
EOF

# Using expert features
sudo gdisk /dev/sdb
# Command (? for help): x          # Expert menu
# Expert command (? for help): l   # Set sector alignment
# Expert command (? for help): a   # Set attributes
# Expert command (? for help): g   # Change disk GUID
# Expert command (? for help): m   # Return to main menu

Therefore, gdisk provides the most comprehensive GPT management capabilities as documented in the GPT fdisk Documentation{target=”_blank”}.

How to View and Analyze Storage Partitions?

Effective Linux disk partitioning analysis requires understanding various Linux tools for displaying, monitoring, and interpreting partition information. Furthermore, comprehensive partition analysis enables informed decision-making for storage management, troubleshooting, and system optimization.

Essential Partition Analysis Commands

Command	Purpose	Output Focus
lsblk	Block device tree view	Hierarchical layout
fdisk -l	Partition table details	Low-level information
df -h	Mounted filesystem usage	Space utilization
blkid	UUID and filesystem types	Partition identification

# Essential commands for partition analysis
lsblk                              # Tree view of all block devices
lsblk -f                           # Include file system information
lsblk -p                           # Show full device paths
lsblk -S                           # Show SCSI information

# Detailed partition information
fdisk -l                           # All partition tables
fdisk -l /dev/sdX                  # Specific device
parted -l                          # All devices with parted
cat /proc/partitions               # Kernel partition table

# File system and usage information
df -h                              # Mounted file systems
df -T                              # Include file system types
blkid                              # UUIDs and file system types
findmnt                            # Mounted file systems tree view

# Example comprehensive disk analysis
echo "=== Block Device Overview ==="
lsblk -f

echo -e "\n=== Partition Tables ==="
parted -l

echo -e "\n=== Mounted File Systems ==="
df -hT

echo -e "\n=== Partition UUIDs ==="
blkid

Advanced Partition Analysis Tools

# Detailed disk and partition information
# Hardware information
lshw -class disk                   # Hardware details
hdparm -I /dev/sdX                 # Drive identification
smartctl -i /dev/sdX               # SMART information

# Partition table analysis
sfdisk -l /dev/sdX                 # Detailed sector information
sfdisk -d /dev/sdX                 # Backup-format partition dump
partx --show /dev/sdX              # Kernel partition information

# Alignment and performance analysis
parted /dev/sdX align-check optimal 1    # Check partition alignment
parted /dev/sdX unit s print       # Show sector-level details

# Create comprehensive system report
cat > /usr/local/bin/disk-report.sh << 'EOF'
#!/bin/bash
echo "=== System Disk Report - $(date) ==="
echo

echo "=== Block Devices ==="
lsblk -f
echo

echo "=== Disk Usage ==="
df -hT
echo

echo "=== Partition Details ==="
parted -l 2>/dev/null
echo

echo "=== Mount Points ==="
findmnt -D
echo

echo "=== RAID Status ==="
cat /proc/mdstat 2>/dev/null || echo "No RAID detected"
echo

echo "=== LVM Status ==="
pvs 2>/dev/null || echo "No LVM detected"
vgs 2>/dev/null
lvs 2>/dev/null
EOF
chmod +x /usr/local/bin/disk-report.sh

Consequently, proper Linux disk partitioning analysis leverages multiple tools as outlined in the Linux System Administrator’s Guide{target=”_blank”}.

How to Create Advanced Linux Partitioning Schemes?

Advanced Linux disk partitioning schemes involve complex layouts optimized for specific use cases such as servers, workstations, or specialized applications. Additionally, advanced schemes may incorporate LVM, RAID, encryption, and multi-boot configurations requiring careful planning and precise implementation.

Server Partition Layout Strategy

Partition	Size	Mount Point	Purpose
EFI System	512MB	/boot/efi	UEFI boot loader
Boot	1GB	/boot	Kernel and initrd
Root	20GB	/	System files
Var	10GB	/var	Variable data
Home	10GB	/home	User directories
Data	Remaining	/data	Application data

# Server partitioning layout example
# Recommended server partition scheme:
# /boot/efi - 512MB (EFI System Partition)
# /boot     - 1GB   (Boot partition)
# /         - 20GB  (Root partition)
# /var      - 10GB  (Variable data)
# /var/log  - 5GB   (Log files)
# /tmp      - 2GB   (Temporary files)
# /home     - 10GB  (User directories)
# swap      - 4GB   (Swap space)
# /data     - Remaining (Application data)

# Automated server partitioning script
cat > /usr/local/bin/server-partition.sh << 'EOF'
#!/bin/bash
DEVICE="$1"

if [ -z "$DEVICE" ] || [ ! -b "$DEVICE" ]; then
    echo "Usage: $0 /dev/sdX"
    echo "Specify a valid block device"
    exit 1
fi

echo "Creating server partition scheme on $DEVICE"
echo "WARNING: This will destroy all data on $DEVICE"
read -p "Continue? (yes/no): " confirm

if [ "$confirm" != "yes" ]; then
    echo "Aborted"
    exit 1
fi

# Create GPT partition table
parted -s $DEVICE mklabel gpt

# Create partitions
parted -s $DEVICE mkpart primary fat32 1MiB 513MiB          # EFI
parted -s $DEVICE mkpart primary ext4 513MiB 1537MiB        # /boot
parted -s $DEVICE mkpart primary ext4 1537MiB 21537MiB      # /
parted -s $DEVICE mkpart primary ext4 21537MiB 31537MiB     # /var
parted -s $DEVICE mkpart primary ext4 31537MiB 36537MiB     # /var/log
parted -s $DEVICE mkpart primary ext4 36537MiB 38537MiB     # /tmp
parted -s $DEVICE mkpart primary ext4 38537MiB 48537MiB     # /home
parted -s $DEVICE mkpart primary linux-swap 48537MiB 52537MiB # swap
parted -s $DEVICE mkpart primary ext4 52537MiB 100%         # /data

# Set partition flags
parted -s $DEVICE set 1 esp on                             # EFI flag

echo "Partition table created successfully"
parted $DEVICE print
EOF
chmod +x /usr/local/bin/server-partition.sh

LVM-Based Storage Management

# LVM (Logical Volume Manager) partitioning scheme
# Advantages: Flexible resizing, snapshots, multiple disks

# Create LVM-ready partitions
parted -s /dev/sdb mklabel gpt
parted -s /dev/sdb mkpart primary 1MiB 513MiB               # EFI
parted -s /dev/sdb mkpart primary 513MiB 1537MiB            # /boot
parted -s /dev/sdb mkpart primary 1537MiB 100%              # LVM

# Set LVM flag
parted -s /dev/sdb set 3 lvm on

# Create physical volume
pvcreate /dev/sdb3

# Create volume group
vgcreate vg_system /dev/sdb3

# Create logical volumes
lvcreate -L 20G -n lv_root vg_system           # Root partition
lvcreate -L 10G -n lv_var vg_system            # Var partition
lvcreate -L 5G -n lv_tmp vg_system             # Tmp partition
lvcreate -L 10G -n lv_home vg_system           # Home partition
lvcreate -L 4G -n lv_swap vg_system            # Swap partition
lvcreate -l 100%FREE -n lv_data vg_system      # Data partition (remaining)

# Display LVM layout
pvs
vgs
lvs

Therefore, advanced Linux disk partitioning requires careful planning as detailed in the Red Hat LVM Guide{target=”_blank”}.

How to Manage Partition Recovery and Backup?

Linux disk partitioning backup and recovery are critical for data protection and system recovery. Additionally, proper backup procedures enable recovery from partition table corruption, accidental deletion, and hardware failures while maintaining data integrity.

Partition Table Backup Strategies

# Create comprehensive partition table backups
# fdisk backup (MBR)
sfdisk -d /dev/sdX > /backup/sdX-partition-backup.sfdisk

# parted backup (MBR and GPT)
parted /dev/sdX unit s print > /backup/sdX-parted-backup.txt

# GPT-specific backup with sgdisk
sgdisk -b /backup/sdX-gpt-backup.bin /dev/sdX

# dd backup of partition table sectors
# MBR backup (first 512 bytes)
dd if=/dev/sdX of=/backup/sdX-mbr-backup.bin bs=512 count=1

# GPT backup (first 34 sectors + last 33 sectors)
SECTORS=$(blockdev --getsz /dev/sdX)
dd if=/dev/sdX of=/backup/sdX-gpt-primary.bin bs=512 count=34
dd if=/dev/sdX of=/backup/sdX-gpt-secondary.bin bs=512 skip=$((SECTORS-33))

# Complete backup script
cat > /usr/local/bin/backup-partitions.sh << 'EOF'
#!/bin/bash
DEVICE="$1"
BACKUP_DIR="/backup/partition-tables"
DATE=$(date +%Y%m%d-%H%M%S)

if [ -z "$DEVICE" ]; then
    echo "Usage: $0 /dev/sdX"
    exit 1
fi

mkdir -p "$BACKUP_DIR"
DEVICE_NAME=$(basename $DEVICE)

echo "Backing up partition table for $DEVICE"

# Detect partition table type
TABLE_TYPE=$(parted $DEVICE print 2>/dev/null | grep "Partition Table:" | awk '{print $3}')

case $TABLE_TYPE in
    msdos)
        echo "Backing up MBR partition table"
        sfdisk -d $DEVICE > "$BACKUP_DIR/${DEVICE_NAME}-mbr-${DATE}.sfdisk"
        dd if=$DEVICE of="$BACKUP_DIR/${DEVICE_NAME}-mbr-${DATE}.bin" bs=512 count=1
        ;;
    gpt)
        echo "Backing up GPT partition table"
        sgdisk -b "$BACKUP_DIR/${DEVICE_NAME}-gpt-${DATE}.bin" $DEVICE
        parted $DEVICE unit s print > "$BACKUP_DIR/${DEVICE_NAME}-gpt-${DATE}.txt"
        ;;
    *)
        echo "Unknown partition table type: $TABLE_TYPE"
        exit 1
        ;;
esac

# Always create parted backup for reference
parted $DEVICE print > "$BACKUP_DIR/${DEVICE_NAME}-parted-${DATE}.txt"

echo "Backup completed in $BACKUP_DIR"
ls -la "$BACKUP_DIR/${DEVICE_NAME}-*-${DATE}.*"
EOF
chmod +x /usr/local/bin/backup-partitions.sh

Recovery Procedures

# Restore partition tables from backups
# Restore MBR with sfdisk
sfdisk /dev/sdX < /backup/sdX-partition-backup.sfdisk

# Restore GPT with sgdisk
sgdisk -l /backup/sdX-gpt-backup.bin /dev/sdX

# Restore MBR with dd
dd if=/backup/sdX-mbr-backup.bin of=/dev/sdX bs=512 count=1

# Emergency recovery script
cat > /usr/local/bin/restore-partitions.sh << 'EOF'
#!/bin/bash
DEVICE="$1"
BACKUP_FILE="$2"

if [ -z "$DEVICE" ] || [ -z "$BACKUP_FILE" ]; then
    echo "Usage: $0 /dev/sdX /backup/backup-file"
    echo "Available backup files:"
    ls -la /backup/partition-tables/
    exit 1
fi

echo "WARNING: This will overwrite the partition table on $DEVICE"
read -p "Continue? (yes/no): " confirm

if [ "$confirm" != "yes" ]; then
    echo "Aborted"
    exit 1
fi

# Detect backup file type and restore accordingly
case "$BACKUP_FILE" in
    *.sfdisk)
        echo "Restoring MBR partition table with sfdisk"
        sfdisk $DEVICE < "$BACKUP_FILE"
        ;;
    *-gpt-*.bin)
        echo "Restoring GPT partition table with sgdisk"
        sgdisk -l "$BACKUP_FILE" $DEVICE
        ;;
    *-mbr-*.bin)
        echo "Restoring MBR with dd"
        dd if="$BACKUP_FILE" of=$DEVICE bs=512 count=1
        ;;
    *)
        echo "Unknown backup file type"
        exit 1
        ;;
esac

# Update kernel partition table
partprobe $DEVICE

echo "Partition table restored successfully"
parted $DEVICE print
EOF
chmod +x /usr/local/bin/restore-partitions.sh

Ultimately, effective disk partitioning requires robust backup and recovery procedures as documented in the Linux Backup and Recovery Guide{target=”_blank”}.

Frequently Asked Questions

What’s the difference between fdisk and parted for Linux disk partitioning?

fdisk is interactive-focused with a command-driven interface that doesn’t apply changes until you write them, while parted can operate in both interactive and command-line modes, applying changes immediately. Additionally, parted has better GPT support and can resize partitions, while fdisk is more traditional and familiar to many users.

Should I use MBR or GPT for Linux disk partitioning?

Use GPT for disks larger than 2TB, systems with UEFI firmware, or when you need more than 4 partitions. Moreover, use MBR only for legacy BIOS systems, smaller disks, or when compatibility with older operating systems is required.

How do I check if my partitions are properly aligned?

Use parted /dev/sdX align-check optimal 1 to check alignment for partition 1. Additionally, modern partitioning tools automatically align partitions to 1MB boundaries, which works well for both HDDs and SSDs.

Can I resize partitions without losing data?

Yes, but it depends on the file system and available space. Furthermore, you can grow ext4, XFS (grow only), and Btrfs partitions online, while shrinking typically requires unmounting and may need file system shrinking first.

What happens if I accidentally delete a partition table?

Data may still be recoverable if only the partition table was damaged. Additionally, tools like testdisk can sometimes recover partition tables, and having recent partition table backups makes recovery much easier.

How do I convert MBR to GPT without losing data?

Use gdisk or sgdisk -g /dev/sdX to convert MBR to GPT non-destructively when space allows. However, always backup important data first as conversion can fail in some situations.

Why is Linux disk partitioning important for system performance?

Proper disk partitioning enables optimized file system placement, reduces fragmentation, allows specialized mount options per partition, and enables advanced features like LVM snapshots for backup and testing.

What tools are best for automated Linux disk partitioning?

Use parted with script mode (-s flag) for automation, sgdisk for GPT-specific scripting, and consider ansible or other configuration management tools for large-scale deployments.

Common Issues and Troubleshooting

Partition Table Corruption

Problem: Partition table becomes corrupted or unreadable during Linux disk partitioning.

# Diagnose partition table issues
parted /dev/sdX print                # Check if table is readable
fdisk -l /dev/sdX                    # Alternative check
dmesg | grep sdX                     # Check kernel messages

# Attempt automatic repair
# For GPT tables
sgdisk -v /dev/sdX                   # Verify and report problems
sgdisk -e /dev/sdX                   # Move backup header to end

# For MBR tables
fdisk /dev/sdX                       # Use 'v' command to verify
# Use 'x' for expert mode, then 'f' to fix partition order

# Recovery from backup
sgdisk -l /backup/sdX-gpt-backup.bin /dev/sdX    # Restore GPT
sfdisk /dev/sdX < /backup/sdX.sfdisk              # Restore MBR

# Last resort: recreate from scratch using backup information
parted /dev/sdX mklabel gpt          # Recreate partition table
# Manually recreate partitions based on backup documentation

Kernel Not Recognizing New Partitions

Problem: New partitions not visible after Linux disk partitioning operation.

# Force kernel to re-read partition table
partprobe /dev/sdX                   # Update kernel partition table
partprobe                            # Update all devices

# Alternative methods
echo 1 > /sys/block/sdX/device/rescan
blockdev --rereadpt /dev/sdX

# Check if partitions are now visible
lsblk /dev/sdX
cat /proc/partitions | grep sdX

# If still not visible, check for errors
dmesg | tail -20                     # Check kernel messages
parted /dev/sdX print                # Verify partition table

# Manual partition registration
partx -a /dev/sdX                    # Add all partitions
partx -a /dev/sdX1                   # Add specific partition

Device Busy Errors

Problem: Cannot perform Linux disk partitioning because device is in use.

# Identify what's using the device
lsof /dev/sdX*                       # Check open files
fuser -v /dev/sdX*                   # Check processes using device

# Check mounted file systems
mount | grep sdX
findmnt /dev/sdX*

# Check swap usage
swapon --show | grep sdX

# Safely stop usage
umount /dev/sdX1                     # Unmount file systems
swapoff /dev/sdX2                    # Disable swap
# Stop any services using the device

# Force unmount if necessary (can cause data loss)
umount -f /dev/sdX1                  # Force unmount
umount -l /dev/sdX1                  # Lazy unmount

Partition Alignment Issues

Problem: Poor performance due to misaligned partitions in Linux disk partitioning.

# Check partition alignment
parted /dev/sdX align-check optimal 1   # Check partition 1
parted /dev/sdX align-check minimal 1   # Check minimal alignment

# Fix alignment by recreating partitions
# Backup data first!
# Delete and recreate with proper alignment
parted /dev/sdX rm 1
parted -a optimal /dev/sdX mkpart primary 0% 50%

# Modern tools automatically align to 1MB boundaries
parted -a optimal /dev/sdX mklabel gpt
parted -a optimal /dev/sdX mkpart primary 1MiB 100%

GPT vs MBR Compatibility Issues

Problem: System won’t boot after changing partition table type.

# Check system firmware type
[ -d /sys/firmware/efi ] && echo "UEFI" || echo "BIOS"

# UEFI systems typically need GPT
# BIOS systems can use either but may need special handling for GPT

# Create hybrid MBR for BIOS compatibility with GPT
gdisk /dev/sdX
# Use 'r' for recovery menu, then 'h' to create hybrid MBR

# Convert between types (DANGEROUS - backup first!)
# MBR to GPT
sgdisk -g /dev/sdX

# GPT to MBR (will lose partitions beyond 4)
sgdisk -m /dev/sdX

# Fix boot issues
# Update bootloader configuration
update-grub                          # Debian/Ubuntu
grub2-mkconfig -o /boot/grub2/grub.cfg  # RHEL/CentOS

Linux Disk Partitioning Best Practices

Plan before partitioning – Design partition layout based on use case and growth requirements
Always backup first – Create partition table backups before making changes
Use appropriate tools – fdisk for MBR, gdisk for GPT, parted for flexibility
Ensure proper alignment – Use -a optimal flag with parted for modern storage
Test partition schemes – Verify partitions work correctly before deploying to production
Document partition layouts – Maintain clear documentation of partition purposes and sizes
Monitor partition health – Regular checks for alignment, usage, and errors
Plan for growth – Leave unallocated space or use LVM for future expansion

Additional Resources

Linux Partition HOWTO: Comprehensive Partitioning Guide
GNU Parted Manual: Official Parted Documentation
GPT fdisk Documentation: gdisk and sgdisk Reference
Linux Storage Management: Red Hat Storage Guide
Partition Recovery Tools: TestDisk Documentation

Master disk partitioning with fdisk and parted to achieve optimal storage organization, performance, and flexibility for your Linux systems through proper partition planning and management.

Related Guides

Continue your Linux learning journey