The practice of running sync; sync; sync before shutdown originates from early Unix systems (BSD 4.2/4.3, SunOS 4) where filesystems lacked robust unmount routines. Administrators needed to manually ensure data was flushed to disk before power cycles.

Current Linux kernels (since ~2.6 era) automatically handle proper filesystem synchronization during shutdown:

// Simplified kernel shutdown sequence (mm/page-writeback.c)
static void sync_filesystems(int wait)
{
    iterate_supers(sync_one_sb, &wait);
}

The shutdown process triggers:

1. Filesystem sync via sync_filesystems()
2. Orderly unmount of all filesystems
3. Final sync of block devices

Exceptions where manual sync might be needed:

# Emergency reboot of frozen system
echo 1 > /proc/sys/kernel/sysrq
echo b > /proc/sysrq-trigger

Or when dealing with:

• Failing storage hardware
• Custom filesystems without proper unmount handlers
• Systems where shutdown binaries might be corrupted

Compare traditional vs modern approaches:

# Traditional (obsolete)
sync; sync; sync; sleep 30; halt

# Modern equivalent
systemctl poweroff --force --no-sync  # Only for emergencies
shutdown -h now                       # Normal shutdown

Different filesystems handle unmount differently:

Verify proper sync during shutdown:

# Monitor kernel messages during shutdown
dmesg --follow | grep -i 'sync\|umount'

# Check filesystem integrity after improper shutdown
fsck -fn /dev/sda1

In early Unix systems (BSD 4.2/4.3, SunOS 4), the sync; sync; sync ritual was crucial because:

• Kernels lacked proper filesystem unmount sequencing
• No automatic buffer flushing during shutdown
• Root filesystem couldn't be cleanly unmounted

Contemporary Linux kernels (2.6+) handle shutdown sequences much more robustly:

// Simplified kernel shutdown sequence (from kernel/power/process.c)
static void kernel_shutdown_prepare(enum system_states state)
{
    blocking_notifier_call_chain(&reboot_notifier_list,
            (state == SYSTEM_HALT) ? SYS_HALT : SYS_POWER_OFF, NULL);
    system_state = state;
    usermodehelper_disable();
    device_shutdown();
    // Filesystem sync happens here automatically
}

Exception cases where manual sync could help:

# Emergency reboot procedure for unresponsive systems
echo 1 > /proc/sys/kernel/sysrq
echo b > /proc/sysrq-trigger

# Alternative when filesystem is corrupted
sync
umount -a -f
reboot -f

To test shutdown behavior:

# Monitor sync operations during shutdown
strace -e trace=file shutdown -h now 2>&1 | grep sync

# Check filesystem state after reboot
tune2fs -l /dev/sda1 | grep 'Filesystem state'
xfs_admin -l /dev/sdb1

Virtualization environments handle this differently:

# Xen DomU shutdown
xl shutdown -w domain_name

# KVM guest shutdown
virsh shutdown --mode acpi vm_name

These methods trigger proper filesystem synchronization through the virtualization stack without manual sync.

While the sync; sync; sync practice persists as folklore, modern Linux systems handle filesystem synchronization automatically during proper shutdown procedures. Only in exceptional cases (filesystem corruption, hardware failures) might manual intervention be necessary.