Skip to main content

Command documentation sourced from the linux-command project This comprehensive command reference is part of the linux-command documentation project.

mke2fs - Create ext2/ext3/ext4 filesystem

The mke2fs command is a powerful filesystem creation utility used to build Linux ext2, ext3, and ext4 filesystems on block devices. It provides extensive customization options for filesystem layout, performance tuning, and feature configuration. As the primary tool for creating ext family filesystems, it supports advanced features like journaling, extended attributes, ACLs, and various optimization parameters for different use cases from desktop systems to enterprise storage solutions.

Basic Syntax​

mke2fs [OPTIONS] [-c|-l filename] device [blocks_count]
mke2fs [OPTIONS] [-t fs-type] [-O feature[,...]] [-L volume-label] device [blocks_count]

Common Options​

Filesystem Type​

  • -t fs-type - Specify filesystem type (ext2, ext3, ext4)
  • -T usage-type - Specify usage type (news, largefile, largefile4, etc.)

Size and Geometry​

  • -b block-size - Specify block size in bytes (1024, 2048, 4096)
  • -g blocks-per-group - Specify blocks per group
  • -G number-of-groups - Specify number of block groups
  • -i bytes-per-inode - Specify bytes/inode ratio
  • -I inode-size - Specify inode size in bytes
  • -J journal-options - Specify journal options

Features and Options​

  • -O feature[,...] - Specify filesystem features
  • -f fragment-size - Specify fragment size in bytes
  • -L volume-label - Set filesystem volume label
  • -U UUID - Set universally unique identifier
  • -m reserved-percentage - Specify percentage of reserved blocks
  • -M mount-point - Set mount point for filesystem

Behavior Control​

  • -c - Check the device for bad blocks before creating filesystem
  • -l filename - Read bad blocks list from file
  • -q - Quiet execution
  • -v - Verbose execution
  • -F - Force creation even if device appears mounted
  • -n - Don't actually create filesystem, just show what would be done

Usage Examples​

Basic Filesystem Creation​

Creating Basic Filesystems​

# Create basic ext4 filesystem
mke2fs -t ext4 /dev/sdb1

# Create ext4 filesystem with label
mke2fs -t ext4 -L "data" /dev/sdb1

# Create ext3 filesystem
mke2fs -t ext3 /dev/sdc1

# Create ext2 filesystem (no journaling)
mke2fs -t ext2 /dev/sdd1

# Create filesystem with specific UUID
mke2fs -t ext4 -U 12345678-1234-1234-1234-123456789abc /dev/sdb1

Checking for Bad Blocks​

# Create filesystem with bad block check
mke2fs -c -t ext4 /dev/sdb1

# Create filesystem with bad block list from file
mke2fs -l badblocks.txt -t ext4 /dev/sdb1

# Check for bad blocks without creating filesystem
mke2fs -n -c -t ext4 /dev/sdb1

Advanced Filesystem Configuration​

Performance Tuning​

# Create filesystem optimized for large files
mke2fs -T largefile -t ext4 /dev/sdb1

# Create filesystem optimized for many small files
mke2fs -t ext4 -N 1000000 /dev/sdb1

# Create filesystem with 4K blocks for large devices
mke2fs -t ext4 -b 4096 /dev/sdb1

# Create filesystem with specific inode ratio
mke2fs -t ext4 -i 4096 /dev/sdb1

# Create filesystem with larger inodes for extended attributes
mke2fs -t ext4 -I 256 /dev/sdb1

Feature Configuration​

# Create ext4 filesystem with specific features
mke2fs -t ext4 -O has_journal,extent,huge_file,flex_bg,uninit_bg,dir_nlink,extra_isize /dev/sdb1

# Create filesystem without journal (ext2-style)
mke2fs -t ext4 -O ^has_journal /dev/sdb1

# Create filesystem with 64bit support
mke2fs -t ext4 -O 64bit /dev/sdb1

# Create filesystem with encryption support
mke2fs -t ext4 -O encrypt /dev/sdb1

# Create filesystem with casefold support
mke2fs -t ext4 -O casefold /dev/sdb1

Reserved Space Configuration​

# Create filesystem with 1% reserved space (for root)
mke2fs -t ext4 -m 1 /dev/sdb1

# Create filesystem with 5% reserved space (default)
mke2fs -t ext4 -m 5 /dev/sdb1

# Create filesystem with no reserved space (for data drives)
mke2fs -t ext4 -m 0 /dev/sdb1

Usage Type Optimization​

Predefined Usage Types​

# Filesystem for desktop use
mke2fs -T desktop -t ext4 /dev/sdb1

# Filesystem for server use
mke2fs -T server -t ext4 /dev/sdb1

# Filesystem for news spool
mke2fs -T news -t ext4 /dev/sdb1

# Filesystem for large files (video, databases)
mke2fs -T largefile -t ext4 /dev/sdb1

# Filesystem for very large files
mke2fs -T largefile4 -t ext4 /dev/sdb1

# Filesystem for many small files
mke2fs -T smallfile -t ext4 /dev/sdb1

Practical Examples​

System Administration​

Disk Partitioning and Setup​

# Format new data partition
fdisk /dev/sdb  # Create partition first
mke2fs -t ext4 -L "data_disk" /dev/sdb1
mkdir /mnt/data
mount /dev/sdb1 /mnt/data

# Format backup drive with specific settings
mke2fs -t ext4 -L "backup" -m 0 -T largefile /dev/sdc1

# Format root filesystem
mke2fs -t ext4 -L "rootfs" -m 5 /dev/sda2

# Format home directory partition
mke2fs -t ext4 -L "home" -m 2 -N 2000000 /dev/sda3

Enterprise Storage Setup​

# Create filesystem for database storage
mke2fs -t ext4 -b 4096 -i 2048 -m 1 -L "db_storage" /dev/mapper/vg0-db

# Create filesystem for virtual machines
mke2fs -t ext4 -T largefile4 -m 0 -L "vm_storage" /dev/mapper/vg0-vms

# Create filesystem with journal optimization
mke2fs -t ext4 -J size=128 -L "critical_data" /dev/mapper/vg0-critical

# Create filesystem with stripe optimization
mke2fs -t ext4 -E stride=128,stripe-width=256 /dev/md0

Performance Optimization​

# Create filesystem for SSD with alignment
mke2fs -t ext4 -E discard /dev/nvme0n1p1

# Create filesystem with specific block groups
mke2fs -t ext4 -g 32768 /dev/sdb1

# Create filesystem with lazy initialization disabled
mke2fs -t ext4 -E lazy_itable_init=0,lazy_journal_init=0 /dev/sdb1

# Create filesystem with quota support
mke2fs -t ext4 -O quota,project /dev/sdb1

Special Applications​

Embedded Systems​

# Create small filesystem for embedded device
mke2fs -t ext4 -b 1024 -N 10000 -m 0 /dev/mmcblk0p2

# Create filesystem with minimal features
mke2fs -t ext2 -b 1024 -m 0 /dev/mtdblock1

# Create filesystem for read-only system
mke2fs -t ext4 -O ^has_journal -m 0 /dev/sdb1

Virtualization and Containers​

# Create filesystem for container storage
mke2fs -t ext4 -O flex_bg,extent -T largefile /dev/loop0

# Create filesystem for VM images
mke2fs -t ext4 -T largefile4 -m 0 -L "vm_images" /dev/vg0/vm_images

# Create sparse filesystem for efficient storage
mke2fs -t ext4 -E nodiscard /dev/mapper/vg0-sparse

Advanced Usage​

Filesystem Features​

Ext4 Advanced Features​

# Enable all ext4 features
mke2fs -t ext4 -O has_journal,extent,huge_file,flex_bg,uninit_bg,dir_nlink,extra_isize,64bit,metadata_csum /dev/sdb1

# Enable project quota support
mke2fs -t ext4 -O quota,project /dev/sdb1

# Enable encryption support
mke2fs -t ext4 -O encrypt,verity /dev/sdb1

# Enable casefold for case-insensitive directories
mke2fs -t ext4 -O casefold /dev/sdb1

# Enable stable_inodes for NFS export
mke2fs -t ext4 -O stable_inodes /dev/sdb1

Journal Configuration​

# Configure journal size
mke2fs -t ext4 -J size=400 /dev/sdb1

# Configure journal device (external journal)
mke2fs -t ext4 -J device=/dev/sdb2 /dev/sdb1

# Create filesystem without journal
mke2fs -t ext2 /dev/sdb1

# Disable journal for specific use case
mke2fs -t ext4 -O ^has_journal /dev/sdb1

Extended Options​

Extended Filesystem Options​

# Create filesystem with specific stripe geometry
mke2fs -t ext4 -E stride=32,stripe-width=64 /dev/md0

# Disable lazy initialization for faster creation
mke2fs -t ext4 -E lazy_itable_init=0,lazy_journal_init=0 /dev/sdb1

# Enable discard/TRIM support
mke2fs -t ext4 -E discard /dev/sdb1

# Set specific number of inodes
mke2fs -t ext4 -N 10000000 /dev/sdb1

# Set filesystem creation time
mke2fs -t ext4 -E resize=2T /dev/sdb1

Inode Configuration​

# Create filesystem with larger inode size
mke2fs -t ext4 -I 512 /dev/sdb1

# Create filesystem with specific inode ratio
mke2fs -t ext4 -i 8192 /dev/sdb1

# Create filesystem with many inodes
mke2fs -t ext4 -N 5000000 /dev/sdb1

# Create filesystem with inline data support
mke2fs -t ext4 -O inline_data /dev/sdb1

Integration and Automation​

Shell Scripts​

Automated Filesystem Creation Script​

#!/bin/bash
# Automated filesystem setup script

DEVICE=$1
LABEL=${2:-"data"}
FSTYPE=${3:-"ext4"}

# Check if device exists
if [ ! -b "$DEVICE" ]; then
    echo "Error: Device $DEVICE does not exist"
    exit 1
fi

# Create filesystem with optimized settings
mke2fs -t "$FSTYPE" \
    -L "$LABEL" \
    -m 1 \
    -c \
    -T server \
    -O has_journal,extent,huge_file,flex_bg \
    "$DEVICE"

if [ $? -eq 0 ]; then
    echo "Filesystem created successfully on $DEVICE"
    echo "Label: $LABEL"
    echo "Type: $FSTYPE"
else
    echo "Error creating filesystem on $DEVICE"
    exit 1
fi

Storage Setup Script​

#!/bin/bash
# Complete storage setup script

setup_filesystem() {
    local device=$1
    local mountpoint=$2
    local label=$3
    local usage_type=$4

    echo "Setting up filesystem on $device..."

    # Create filesystem
    mke2fs -t ext4 \
        -L "$label" \
        -T "$usage_type" \
        -c \
        "$device"

    # Create mount point
    mkdir -p "$mountpoint"

    # Add to /etc/fstab
    UUID=$(blkid -s UUID -o value "$device")
    echo "UUID=$UUID   $mountpoint   ext4   defaults   0 2" >> /etc/fstab

    # Mount filesystem
    mount "$mountpoint"

    echo "Filesystem $label setup complete"
}

# Usage examples
setup_filesystem "/dev/sdb1" "/mnt/data" "data" "largefile4"
setup_filesystem "/dev/sdc1" "/mnt/backup" "backup" "largefile"

System Integration​

Cloud Instance Storage Setup​

#!/bin/bash
# Cloud instance storage initialization

# Setup additional ephemeral storage
if [ -b /dev/nvme1n1 ]; then
    # Create partitions
    echo -e "n\np\n1\n\n\nw" | fdisk /dev/nvme1n1

    # Create filesystem optimized for cloud workloads
    mke2fs -t ext4 \
        -L "ephemeral" \
        -m 0 \
        -T largefile4 \
        -E discard,nodiscard \
        /dev/nvme1n1p1

    # Mount and configure
    mkdir -p /mnt/ephemeral
    mount /dev/nvme1n1p1 /mnt/ephemeral
    chmod 777 /mnt/ephemeral
fi

Troubleshooting​

Common Issues​

Device Busy or Mounted​

# Error: device is mounted
# Solution: Unmount first or force creation
umount /dev/sdb1
mke2fs -t ext4 /dev/sdb1

# Force creation (dangerous!)
mke2fs -F -t ext4 /dev/sdb1

# Check if device is in use
fuser -mv /dev/sdb1
lsof /dev/sdb1

Permission Issues​

# Error: permission denied
# Solution: Use sudo or run as root
sudo mke2fs -t ext4 /dev/sdb1

# Check device permissions
ls -l /dev/sdb1

# Add user to disk group (alternative)
sudo usermod -a -G disk $USER

Insufficient Space​

# Error: no space left on device
# Solution: Check device size and blocks count
fdisk -l /dev/sdb
mke2fs -t ext4 /dev/sdb1 1048576  # Specify exact block count

# Create smaller filesystem
mke2fs -t ext4 /dev/sdb1 500000

Bad Blocks​

# Handle bad blocks
badblocks -sv /dev/sdb1 > badblocks.txt
mke2fs -t ext4 -l badblocks.txt /dev/sdb1

# Skip bad blocks during creation
mke2fs -t ext4 -c /dev/sdb1

# Mark blocks as bad after filesystem creation
e2fsck -l badblocks.txt /dev/sdb1
  • fdisk - Partition table manipulator
  • parted - Partition editor
  • fsck - Filesystem consistency check
  • e2fsck - ext2/ext3/ext4 filesystem checker
  • resize2fs - ext2/ext3/ext4 filesystem resizer
  • tune2fs - Adjust tunable filesystem parameters
  • dumpe2fs - Dump ext2/ext3/ext4 filesystem information
  • blkid - Locate/print block device attributes
  • mount - Mount filesystem
  • umount - Unmount filesystem
  • df - Report filesystem disk space usage

Best Practices​

  1. Always backup data before creating filesystems
  2. Check for bad blocks on new or suspect devices with -c
  3. Choose appropriate block size: 4K for most systems, smaller for embedded
  4. Set meaningful labels with -L for easier identification
  5. Reserve appropriate space: 1-5% for critical systems, 0% for pure data
  6. Select correct usage type with -T for optimal performance
  7. Test filesystem creation with -n flag before actual creation
  8. Verify filesystem integrity after creation with fsck
  9. Document filesystem parameters for future reference
  10. Consider future growth when setting inode count and geometry

Performance Tips​

  1. Use 4K block size for most modern storage devices
  2. Enable 64bit support for filesystems larger than 16TB
  3. Use flex_bg feature for better block group allocation
  4. Set appropriate inode ratio based on expected file sizes
  5. Enable extent feature for better large file handling
  6. Use external journal for high-performance systems
  7. Align filesystem with underlying storage geometry
  8. Disable lazy initialization when fast creation is needed
  9. Use appropriate reserved blocks based on usage pattern
  10. Enable metadata checksumming for better data integrity

The mke2fs command is the comprehensive tool for creating ext family filesystems with extensive customization options. Its support for advanced features, performance tuning, and various use cases makes it essential for system administrators managing Linux storage systems, from desktop workstations to enterprise storage solutions.

Sponsors:DigitalOceanVultrSetappCloudflare