Learn Linux Filesystem - Ecosystem, Alternatives & Final Reflection

#Introduction

This is the final episode of the Learn Linux Filesystem series. You've traveled through 22 episodes: from block devices and inodes, creating ext4, XFS, btrfs, and ZFS filesystems, managing mount and fstab, to production hardening and looking at the future roadmap. Now it's time to bring it all together.

Episode 22 does three things: compares all the filesystems in one mental map, introduces alternatives we haven't covered (F2FS and NILFS2), and reaffirms the two most misunderstood principles — RAID isn't a filesystem and a filesystem isn't a backup.

Finally, we recap the entire series with a production checklist you can take to real projects, plus learning resources to continue.

#The Mental Map of the Four Main Filesystems

#One-Glance Comparison

The four filesystems at the heart of this series can be summarized in one mental table:

fitur         ext4   XFS    btrfs   ZFS
journaling     ya     ya     COW     COW
checksum data  tidak  tidak  ya      ya
snapshot       via   via    native  native
               LVM    xfsdump
kompresi       tidak  tidak  ya      ya
multi-device   tidak  tidak  ya      ya
pool/volume    tidak  tidak  tidak   ya

• ext4: simple, stable, the default everywhere.
• XFS: high throughput for large files, the RHEL default.
• btrfs: COW, snapshots, and compression built into the kernel.
• ZFS: integrity, pools, and RAIDZ in one package.

Each wins in its own domain; none wins in all domains.

#When to Choose Which

The decision outline we built in episode 18:

• ext4: the safe default, root filesystems, medium databases.
• XFS: media, archives, large files, RHEL ecosystems.
• btrfs: system snapshots, container storage, compression.
• ZFS: critical storage, multi-disk pools, self-healing needs.

#Alternatives Worth Knowing

#F2FS: A Filesystem for Flash

F2FS (Flash-Friendly File System) is designed specifically for NAND flash (SSDs, eMMC, SD cards) — understanding flash characteristics like garbage collection and write amplification:

sudo mkfs.f2fs /dev/sda1
sudo mount -t f2fs /dev/sda1 /mnt/flash

F2FS organizes writes into flash-friendly segments and often delivers better write performance on NAND-type storage. It suits embedded devices and SD cards, and is less relevant for enterprise NVMe that manages its own alignment. Check tool availability with mkfs.f2fs -V before setting it up in your lab.

#NILFS2: Continuous Snapshotting

NILFS2 automatically keeps snapshots continuously without configuration — a checkpoint is created every few seconds:

sudo mount -t nilfs2 /dev/sda1 /mnt/nilfs
lscp /mnt/nilfs

NILFS2 is useful for systems that can't schedule manual snapshots. However, its ecosystem and support are far smaller than the main filesystems — for general production, btrfs or ZFS is better.

#tmpfs and Network Filesystems

Complete the mental map with two other categories:

• tmpfs: a filesystem in RAM — data is lost at reboot, very fast.
• NFS/CIFS: network protocols that expose a host filesystem to the network.

Both occupy different layers and don't replace on-disk filesystems.

#Two Principles You Must Remember

#RAID Is Not a Filesystem

RAID works at the block level — it combines several disks and protects against physical disk failure. It knows nothing about files, directories, or checksums. RAID can still hand a corrupt block to a filesystem without realizing it.

The difference is crucial:

• RAID mirror handles dead disks, not bit rot.
• RAIDZ/parity handles one or two failed disks, not logical corruption.
• Filesystem checksums catch corrupt blocks that slip past RAID.

With btrfs and ZFS, which have checksums and RAID built in, you get both at once — this is why ZFS is often chosen for critical storage.

#A Filesystem Is Not a Backup

This is the most misunderstood of all:

• A snapshot is not a backup — it shares physical blocks with the original data.
• RAID is not a backup — deleting a file deletes it from every mirror.
• Checksums are not a backup — they repair corrupt blocks, not lost files.

A real backup is a recoverable copy of data in another place — via btrfs send/zfs send, xfsdump, or an EBS snapshot to another region. Without this, all other protection only delays the disaster.

#Recap and the Production Checklist

#Journey Summary

0-2  : fondasi, sejarah, anatomi
3-6  : ext4, XFS, btrfs, ZFS dasar
7-11 : mount, quota/enkripsi, snapshot, workload, repair
12-14: advanced ext4/XFS, btrfs, ZFS
15-19: container, tuning, monitoring, pemilihan, cloud
20-22: roadmap, hardening, refleksi

Each phase builds on the previous one — from understanding concepts, creating and operating, optimizing, to securing.

#The Production Checklist

When deploying new storage, go through this checklist:

[ ] pilih filesystem sesuai workload (bukan kebiasaan)
[ ] mkfs dengan fitur modern aktif (metadata_csum, 64bit)
[ ] UUID di fstab, mount options ketat (noatime, noexec untuk /tmp)
[ ] quota aktif dan batas wajar per user/proyek
[ ] enkripsi LUKS atau native jika data sensitif
[ ] RAID/pool dengan redundansi sesuai prioritas data
[ ] snapshot terjadwal (harian/mingguan)
[ ] backup offsite dengan send/receive atau objek storage
[ ] scrub rutin di luar jam sibuk
[ ] monitoring SMART, kapasitas, dan health filesystem
[ ] alerting untuk ambang batas kritis
[ ] dokumentasi layout disk, mount, dan prosedur recovery

#Resources for Further Learning

To go deeper:

• Man pages: mkfs.*, fsck*, btrfs(8), zpool(8), zfs(8).
• kernel.org/filesystems for ext4, xfs, and btrfs.
• openzfs.org and btrfs.readthedocs.io for official documentation.
• RHEL, Debian, and openSUSE documentation for each respective filesystem.

#Conclusion

Twenty-three episodes may feel long, but the foundation you've built — understanding inodes, journaling, COW, checksums, snapshots, and tuning — will accompany you throughout your career in storage. Filesystems are one of the layers that change the least and last the longest.

Key takeaways:

• The four main filesystems: ext4 (simple), XFS (throughput), btrfs (COW), ZFS (integrity + pools).
• F2FS for NAND flash, NILFS2 for continuous snapshots, tmpfs for RAM.
• RAID handles dead disks; checksums catch corruption; they're different.
• Snapshots and RAID are not backups — always have a copy elsewhere.
• The production checklist: choose with reason, configure, protect, monitor, document.
• Keep learning from man pages and official documentation — documentation is your best friend.

Thank you for following the Learn Linux Filesystem series. Now, take a disk that doesn't matter, try everything you've learned, and make that experimentation part of your expertise. See you in the next series!