Optimize Linux RAID configuration for maximum disk performance with mdadm and advanced tuning

#!/usr/bin/env bash

set -euo pipefail

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'

# Default values
RAID_LEVEL="10"
CHUNK_SIZE="512"
DISKS=()
FORCE=false

# Cleanup function
cleanup() {
    if [ $? -ne 0 ]; then
        echo -e "${RED}[ERROR] Script failed. Check logs above.${NC}" >&2
        if [ ${#DISKS[@]} -gt 0 ] && [ -e /dev/md0 ]; then
            echo -e "${YELLOW}[CLEANUP] Stopping RAID array...${NC}"
            mdadm --stop /dev/md0 2>/dev/null || true
        fi
    fi
}

trap cleanup ERR

usage() {
    cat << EOF
Usage: $0 [OPTIONS] <disk1> <disk2> [disk3] [disk4]

Optimize Linux RAID configuration for maximum disk performance.

Options:
    -l, --level LEVEL    RAID level (0, 1, 5, 6, 10) [default: 10]
    -c, --chunk SIZE     Chunk size in KB [default: 512]
    -f, --force          Skip confirmation prompts
    -h, --help           Show this help

Examples:
    $0 /dev/sdb /dev/sdc /dev/sdd /dev/sde
    $0 -l 1 -c 256 /dev/sdb /dev/sdc
    $0 --force --level 0 /dev/nvme0n1 /dev/nvme1n1

Note: This will DESTROY all data on specified disks!
EOF
}

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        -l|--level)
            RAID_LEVEL="$2"
            shift 2
            ;;
        -c|--chunk)
            CHUNK_SIZE="$2"
            shift 2
            ;;
        -f|--force)
            FORCE=true
            shift
            ;;
        -h|--help)
            usage
            exit 0
            ;;
        /dev/*)
            DISKS+=("$1")
            shift
            ;;
        *)
            echo -e "${RED}Unknown option: $1${NC}" >&2
            usage
            exit 1
            ;;
    esac
done

# Validation
if [ ${#DISKS[@]} -lt 2 ]; then
    echo -e "${RED}Error: At least 2 disks required${NC}" >&2
    usage
    exit 1
fi

if [ "$EUID" -ne 0 ]; then
    echo -e "${RED}Error: This script must be run as root${NC}" >&2
    exit 1
fi

# Detect distribution
if [ -f /etc/os-release ]; then
    . /etc/os-release
    case "$ID" in
        ubuntu|debian)
            PKG_MGR="apt"
            PKG_INSTALL="apt install -y"
            MDADM_CONF="/etc/mdadm/mdadm.conf"
            UPDATE_INITRD="update-initramfs -u"
            ;;
        almalinux|rocky|centos|rhel|ol|fedora)
            PKG_MGR="dnf"
            PKG_INSTALL="dnf install -y"
            MDADM_CONF="/etc/mdadm.conf"
            UPDATE_INITRD="dracut -f"
            ;;
        amzn)
            PKG_MGR="yum"
            PKG_INSTALL="yum install -y"
            MDADM_CONF="/etc/mdadm.conf"
            UPDATE_INITRD="dracut -f"
            ;;
        *)
            echo -e "${RED}Unsupported distribution: $ID${NC}" >&2
            exit 1
            ;;
    esac
else
    echo -e "${RED}Cannot detect distribution${NC}" >&2
    exit 1
fi

echo -e "${BLUE}Linux RAID Performance Optimization Setup${NC}"
echo "=========================================="

# Confirmation
if [ "$FORCE" = false ]; then
    echo -e "${YELLOW}This will DESTROY all data on: ${DISKS[*]}${NC}"
    echo -e "${YELLOW}RAID Level: $RAID_LEVEL, Chunk Size: ${CHUNK_SIZE}KB${NC}"
    read -p "Continue? (yes/NO): " confirm
    if [ "$confirm" != "yes" ]; then
        echo "Aborted."
        exit 0
    fi
fi

echo -e "${GREEN}[1/8] Installing required packages...${NC}"
if [ "$PKG_MGR" = "apt" ]; then
    apt update
fi
$PKG_INSTALL mdadm gdisk parted smartmontools hdparm

echo -e "${GREEN}[2/8] Validating disks...${NC}"
for disk in "${DISKS[@]}"; do
    if [ ! -b "$disk" ]; then
        echo -e "${RED}Error: $disk is not a valid block device${NC}" >&2
        exit 1
    fi
    echo "Checking $disk..."
    smartctl -H "$disk" || echo -e "${YELLOW}Warning: SMART check failed for $disk${NC}"
done

echo -e "${GREEN}[3/8] Preparing disks...${NC}"
for disk in "${DISKS[@]}"; do
    echo "Clearing partition table on $disk..."
    sgdisk --zap-all "$disk"
    
    # Set I/O scheduler based on disk type
    disk_name=$(basename "$disk")
    if [[ "$disk" == *"nvme"* ]] || [ "$(cat /sys/block/$disk_name/queue/rotational 2>/dev/null)" = "0" ]; then
        echo "none" > "/sys/block/$disk_name/queue/scheduler" 2>/dev/null || echo "mq-deadline" > "/sys/block/$disk_name/queue/scheduler"
        echo "Configured SSD scheduler for $disk"
    else
        echo "mq-deadline" > "/sys/block/$disk_name/queue/scheduler"
        echo "Configured HDD scheduler for $disk"
    fi
done

echo -e "${GREEN}[4/8] Creating RAID array...${NC}"
mdadm_args=(
    --create /dev/md0
    --level="$RAID_LEVEL"
    --raid-devices="${#DISKS[@]}"
    --chunk="$CHUNK_SIZE"
    --bitmap=internal
    --assume-clean
)

# Add layout for RAID 10
if [ "$RAID_LEVEL" = "10" ]; then
    mdadm_args+=(--layout=f2)
fi

mdadm "${mdadm_args[@]}" "${DISKS[@]}"

# Wait for array to be ready
echo "Waiting for RAID array to initialize..."
sleep 5

echo -e "${GREEN}[5/8] Saving RAID configuration...${NC}"
mkdir -p "$(dirname "$MDADM_CONF")"
mdadm --detail --scan | tee -a "$MDADM_CONF"
$UPDATE_INITRD

echo -e "${GREEN}[6/8] Optimizing RAID parameters...${NC}"
# Stripe cache size (for RAID 4/5/6)
if [[ "$RAID_LEVEL" =~ ^(4|5|6)$ ]]; then
    echo 8192 > /sys/block/md0/md/stripe_cache_size
fi

# Read-ahead optimization
blockdev --setra 65536 /dev/md0

# Queue settings
echo "mq-deadline" > /sys/block/md0/queue/scheduler
echo 128 > /sys/block/md0/queue/nr_requests

# Disable NCQ for better performance with RAID
echo 1 > /sys/block/md0/queue/nomerges

echo -e "${GREEN}[7/8] Creating optimization service...${NC}"
cat > /etc/systemd/system/raid-optimize.service << 'EOF'
[Unit]
Description=Optimize RAID array performance
After=local-fs.target

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/bin/bash -c '[ -f /sys/block/md0/md/stripe_cache_size ] && echo 8192 > /sys/block/md0/md/stripe_cache_size || true'
ExecStart=/bin/bash -c 'blockdev --setra 65536 /dev/md0'
ExecStart=/bin/bash -c 'echo mq-deadline > /sys/block/md0/queue/scheduler'
ExecStart=/bin/bash -c 'echo 128 > /sys/block/md0/queue/nr_requests'
ExecStart=/bin/bash -c 'echo 1 > /sys/block/md0/queue/nomerges'

[Install]
WantedBy=multi-user.target
EOF

chmod 644 /etc/systemd/system/raid-optimize.service
systemctl daemon-reload
systemctl enable raid-optimize.service

# Create sysctl optimizations
cat > /etc/sysctl.d/99-raid-performance.conf << EOF
# RAID Performance Optimizations
vm.dirty_ratio = 15
vm.dirty_background_ratio = 5
vm.dirty_expire_centisecs = 12000
vm.dirty_writeback_centisecs = 1500
vm.vfs_cache_pressure = 50
kernel.sched_min_granularity_ns = 10000000
kernel.sched_wakeup_granularity_ns = 15000000
EOF

sysctl -p /etc/sysctl.d/99-raid-performance.conf

echo -e "${GREEN}[8/8] Verifying RAID array...${NC}"
if [ ! -b /dev/md0 ]; then
    echo -e "${RED}Error: RAID array /dev/md0 not created${NC}" >&2
    exit 1
fi

echo -e "${BLUE}RAID Array Details:${NC}"
mdadm --detail /dev/md0

echo -e "${BLUE}Performance Settings:${NC}"
echo "Scheduler: $(cat /sys/block/md0/queue/scheduler | grep -o '\[.*\]' | tr -d '[]')"
echo "Read-ahead: $(blockdev --getra /dev/md0) sectors"
echo "Queue depth: $(cat /sys/block/md0/queue/nr_requests)"

echo
echo -e "${GREEN}✓ RAID optimization complete!${NC}"
echo
echo -e "${YELLOW}Next steps:${NC}"
echo "1. Create filesystem: mkfs.ext4 -F /dev/md0"
echo "2. Mount with optimizations: mount -o noatime,nodiratime,barrier=0 /dev/md0 /mnt"
echo "3. Add to /etc/fstab for persistence"
echo
echo -e "${YELLOW}Performance monitoring:${NC}"
echo "• Monitor: watch -n1 'cat /proc/mdstat'"
echo "• Test: dd if=/dev/zero of=/mnt/testfile bs=1M count=1000 oflag=direct"