4.2. Projekt

4.2.1. Konfiguration

Es wurde ein Script für den Test erstellt:

#!/bin/bash

# Function to install required packages for filesystem management
install_package() {
    local package=$1
    if ! dpkg -s "$package" &>/dev/null; then
        echo "$package is not installed. Installing now..."
        sudo apt-get update && sudo apt-get install -y "$package"
    fi
}

# Function to validate the filesystem and format the disk
format_filesystem() {
    local fs=$1
    local selected_disk=$2

    echo "Formatting $selected_disk with $fs..."

    case $fs in
        "ext3"|"ext4")
            install_package "e2fsprogs"
            mkfs.${fs} -F /dev/${selected_disk} > /dev/null 2>&1
            ;;
        "ntfs")
            install_package "ntfs-3g"
            mkfs.${fs} -F /dev/${selected_disk} > /dev/null 2>&1
            ;;
        "exfat")
            install_package "exfatprogs"
            mkfs.${fs} -f /dev/${selected_disk} > /dev/null 2>&1
            ;;
        "xfs")
            install_package "xfsprogs"
            mkfs.${fs} -f /dev/${selected_disk} > /dev/null 2>&1
            ;;
        *)
            echo "Unsupported filesystem: $fs"
            return 1
            ;;
    esac
    echo "Formatting complete."
    return 0
}

# Function to run read performance test using fio
run_perf_test_read() {
    local selected_disk=$1
    local test_size_gb=$2 

    # Ensure to install fio if not already installed
    install_package "fio"
    install_package "jq"

    # drop caches to have a fair test
    sudo sh -c 'echo 3 > /proc/sys/vm/drop_caches'

    echo "Starting read performance test with a $test_size_gb GB file size..."
    # Using fio to perform the read test and extract only read speed
    local read_result=$(fio --name=read_test --filename=/dev/${selected_disk} --direct=1 --rw=read --bs=64k --size=${test_size_gb}G --numjobs=1 --runtime=60 --group_reporting --ioengine=libaio --output-format=json)
    local read_speed=$(echo $read_result | jq '.jobs[0].read.bw' | awk '{print $1/1024 " MB/s"}')
    echo "Read Speed: $read_speed"
}

# Function to run write performance test using fio
run_perf_test_write() {
    local selected_disk=$1
    local test_size_gb=$2 

    # Ensure to install fio and jq if not already installed
    install_package "fio"
    install_package "jq"

    echo "Starting write performance test with a $test_size_gb GB file size..."
    # Using fio to perform the write test and output results in JSON format
    local write_result=$(fio --name=write_test --filename=/dev/${selected_disk} --rw=write --bs=64k --size=${test_size_gb}G --numjobs=1 --runtime=60 --group_reporting --ioengine=libaio --output-format=json)
    
    # Parsing the total bytes written and the total runtime using jq, then calculate MB/s
    #local total_bytes=$(echo "$write_result" | jq '.jobs[0].write.bw_bytes')
    local total_bytes=$(echo "$write_result" | jq '.jobs[0].write.bw')
    local total_time_ms=$(echo "$write_result" | jq '.jobs[0].write.runtime')  # in milliseconds

    # Convert total time from milliseconds to seconds for MB/s calculation
    local total_time_s=$(echo "scale=3; $total_time_ms / 1000" | bc)
    #local write_speed=$(echo "scale=2; $total_bytes / $total_time_s / 1024 / 1024" | bc)
    local write_speed=$(echo "scale=2; $total_bytes / 1024" | bc)

    echo "Write Speed: $write_speed MB/s"
}

# Check if the script is run as root
if [[ $(id -u) -ne 0 ]]; then
    echo "This script must be run as root."
    exit 1
fi

# Fetch disk details and store them in arrays
mapfile -t disks < <(lsblk -dn -o NAME)
mapfile -t sizes < <(lsblk -dn -o SIZE)
mapfile -t models < <(lsblk -dn -o MODEL)
mapfile -t mountpoints < <(lsblk -dn -o MOUNTPOINT)

# Display the list of all disks with numbers
echo "Available disks:"
for i in "${!disks[@]}"; do
    echo "$((i+1))) ${disks[i]} - ${sizes[i]} - ${models[i]} - ${mountpoints[i]}"
done

# Prompt the user to select a disk by number
read -p "Enter the number of the disk to use: " disk_number

# Validate input and retrieve disk name
if [[ $disk_number =~ ^[0-9]+$ ]] && [ "$disk_number" -ge 1 ] && [ "$disk_number" -le "${#disks[@]}" ]; then
    selected_disk=${disks[$((disk_number-1))]}
    echo "You have selected: ${selected_disk} - ${sizes[$((disk_number-1))]}"

    # Confirm format operation
    read -p "Are you sure you want to format ${selected_disk} (yes/no)? " confirm
    if [[ $confirm == "yes" ]]; then
        # Requesting user input for the test size
        read -p "Please enter the test size in GB (e.g., 1 for 1GB): " test_size_gb

        # Define file systems to test
        declare -a filesystems=("ext3" "ext4" "ntfs" "exfat" "xfs")

        # Loop over each filesystem
        for fs in "${filesystems[@]}"; do
            format_filesystem $fs $selected_disk

            # Perform the disk performance test
            run_perf_test_write "$selected_disk" "$test_size_gb"
            run_perf_test_read "$selected_disk" "$test_size_gb"
        done
    else
        echo "Format operation cancelled."
    fi
else
    echo "Invalid selection. Please run the script again with a valid number."
fi

Das Script fragt ab welche Festplatte für den Test verwendet werden soll. Nach einer Bestätigung des Nutzers kann mit den Tests begonnen werden. Es wird über die von uns definierten Filesysteme gelooped und die Festplatte mit dem jeweiligen Filesystem formatiert. Für manche Filesysteme werden extra Pakete unter dem verwendeten OS (Ubuntu 22.04) benötigt (ExFAT, NTFS und XFS), diese werden automatisch installiert. Anschließend werden getrennt voneinander Lese- und Schreibgeschwindigkeit für das aktuell auf der Festplatte verwendete Filesystem getestet. Für unsere Versuche haben wir uns darauf geeinigt 1GB große Testdateien zu verwenden. Der Test wurde mit dem bewährten Linux-Paket fio (Flexible I/O Tester) durchgeführt. Es wurde darauf geachtet den Cache vor dem Test zu leeren, damit alle Filesysteme exakt die gleichen Bedingungen haben.

Das Script gibt aus welches Filesystem aktuell verwendet wird und die durchschnittliche Geschwindigkeit für Lese- und Schreibtest.

4.2.2. Vergleich

4.2.2.1. Performance

Für den Performance Vergleich wird das Tool FIO (Flexible I/O Tester) verwendet. Es ist ein gängiges Tool zum messen von Festplatten/Filesystem Performance. Es kann viele verschiedene Workloads simulieren.

Getestet wurde auf drei verschiedene Storages, einer alten HDD, einer SSD und auf einem Storage System, der Netapp E2800 (https://www.netapp.com/de/data-storage/e-series/e2800/), bestückt mit HDDs und einem DDP (Dynamic Disk Pool)

Das Netapp System wurde hinzugefügt, um einen Vergleich zu größeren Installationen zu haben.

Storage	EXT3	EXT4	NTFS	ExFAT	XFS
HDD READ	125.27 MB/s	125.29 MB/s	125.30 MB/s	125.29 MB/s	125.28 MB/s
HDD WRITE	158.47 MB/s	152.82 MB/s	166.09 MB/s	165.99 MB/s	166.09 MB/s
SSD READ	545.37 MB/s	555.25 MB/s	540.78 MB/s	550.22 MB/s	552.15 MB/s
SSD WRITE	495.48 MB/s	505.32 MB/s	490.66 MB/s	500.99 MB/s	502.88 MB/s
Netapp E2800 DDP-Raid READ	21.91 MB/s	25.88 MB/s	28.11 MB/s	26.77 MB/s	26.19 MB/s
Netapp E2800 DDP-Raid WRITE	923.57 MB/s	902.38 MB/s	880.17 MB/s	850.71 MB/s	831.75 MB/s

In graphischer Form sind die Ergebnisse wie folgt:

Die Ergebnisse sind relativ ähnlich, vorallem bei dem HDD Test sind die Filesysteme quasi identisch. Ein Filesystem kann aber natürlich auch nur begrenzt Einfluss auf die Geschwindigkeit nehmen, da v.a. die Hardware ausschlaggebend ist. Erst bei der SSD und der Schreibgeschwindigkeit auf dem Netapp System mit 50GB Testdaten fallen die Unterschiede deutlicher auf, da hier die Hardware sehr performant ist und somit kleine Unterschiede in der Filesystemperformance wesehntlich offensichtlichere Auswirkungen haben.

Für eine Vollumfängliche Aussage über die Filesysteme müsste eine Vielzahl von Tests mit verschiedenen Kombinationen aus Fileanzahl und Filegröße durchgeführt werden. Dies übersteigt allerdings den Rahmen dieser Arbeit.

4.2.2.2. Platzbedarf

Der Platzbedarf eines Dateisystems hängt von verschiedenen Faktoren ab, darunter das Vorhandensein von Journaling, der Overhead und die Effizienz. Journaling hilft dabei, die Integrität des Dateisystems zu gewährleisten, kann aber zusätzlichen Speicherplatz beanspruchen. Overhead bezieht sich auf den zusätzlichen Speicherbedarf, der durch Verwaltungsinformationen entsteht, während die Effizienz angibt, wie gut der verfügbare Speicherplatz genutzt wird.

Dateisystem	Journaling	Overhead	Effizienz
EXT3	Ja	Mittel	Mittel
EXT4	Ja	Gering	Hoch
NTFS	Ja	Mittel	Hoch
ExFAT	Nein	Gering	Hoch
XFS	Ja	Gering	Hoch

4.2.2.3. Zuverlässigkeit

Die Zuverlässigkeit eines Dateisystems ist entscheidend für die Datensicherheit und -integrität. Wichtige Aspekte sind hier das Journaling, die Datenintegrität und die Fehlerkorrektur. Zudem spielt die Eignung für unterschiedliche Anwendungsszenarien eine Rolle, z.B. für den Einsatz in Linux-Distributionen, auf Wechseldatenträgern oder in unternehmenskritischen Umgebungen.

Dateisystem	Journaling	Datenintegrität	Fehlerkorrektur	Anwendungsszenarien
EXT3	Ja	Hoch	Mittel	Weit verbreitet in Linux-Distributionen
EXT4	Ja	Hoch	Hoch	Verbesserte Leistung und Skalierbarkeit
NTFS	Ja	Hoch	Hoch	Solide Zuverlässigkeit und Mechanismen zur Fehlerkorrektur
ExFAT	Nein	Mittel	Mittel	Entwickelt für Wechseldatenträger
XFS	Ja	Hoch	Hoch	Hochleistungsfähig, geeignet für große Dateisysteme und unternehmenskritische Umgebungen

4.2.2.4. Zugriffskontrolle

Die Zugriffskontrolle auf Dateien und Verzeichnisse ist ein wesentliches Merkmal eines Dateisystems. Dabei spielen UNIX-Dateirechte, Access Control Lists (ACLs) und die Möglichkeit der Verschlüsselung eine wichtige Rolle. Diese Mechanismen tragen dazu bei, den Zugriff auf sensible Daten zu steuern und diese vor unbefugtem Zugriff zu schützen.

Dateisystem	UNIX-Dateirechte	Access Control Lists (ACLs)	Verschlüsselung
EXT3	Ja	Ja	Nein
EXT4	Ja	Ja (POSIX-Erweiterungen)	Ja
NTFS	Ja	Ja	Ja (EFS)
ExFAT	Nein	Nein	Nein
XFS	Ja	Ja	Nein

4.2.2.5. Spezielle Features

EXT4 ist vollständig rückwärtskompatibel zu EXT3 und sogar EXT2. Es kann extrem große Datenmengen aufnehmen und ist pro Volume auf 1 Exabyte, pro Datei auf 16 Terabyte beschränkt und daher besonders für den Einsatz im Enterprise-Umfeld geeignet. Eine hohe Verfügbarkeit wird auch durch die Möglichkeit der Online Defragmentierung erzielt: Diese kann durchgeführt werden während weiterhin auf das Dateisystem zugegriffen wird.

NTFS wurde für Windows entwickelt, bietet aber mit Einschränkungen auch einen Zugriff auf unixartigen Betriebssystemen. Speziell für Windows bietet es eine Komprimierung der Daten an um Speicherplatz zu sparen. Es wurde mit Windows Vista eingeführt und ist seitdem verpflichtender Standard. Zuvor wurde FAT32 eingesetzt.

ExFAT zeichnet sich durch seine besonders hohe Kompatibilität zwischen den verschiedenen Betriebssystemen aus, deutlich flexibler als bei NTFS. Es ist zudem hinsichtlich der Dateigrößen nicht begrenzt, allerdings arbeitet es am effizientesten wenn es auf eher kleineren Datenspeichern zum Einsatz kommt. Eine Zugriffskontrolle mittels UNIX-Dateirechten oder ACLs wird allerdings leider nicht unterstützt.

XFS sorgt by design dafür, dass Defragmentierung so gering wie möglich gehalten wird. Die Datenblöcke werden so gut wie möglich zusammengehalten und verhindern so eine stark sinkende Performance durch Defragmentierung. Zudem wurde das Dateisystem für parallele Zugriffe konzipiert. Es weist Speicher in Zuordnungsgruppen zu und lässt diese wie unabhängige Dateisysteme agieren. Dadurch wird die Performance auch bei vielen parallelen Zugriffen nicht beeinträchtigt.

Besonders Journaling ein wichtiges Feature, welches abgesehen von exFAT auf allen genannten Dateisystemen unterstützt wird. Bei Dateisystemen in denen dies nicht zum Einsatz kommt, können die Daten nach einem Systemabsturz möglicherweise nicht mehr konsistent wiederhergestellt werden was Datenverlust zur Folge hätte.