Corruption-proof SD card filesystem for embedded Linux?
The best resistance against corruption on a single SD card would be offered by BTRFS in RAID1 mode with automatic scrub run every predefined period of time.
The benefits:
- retaining ability to RW to the filesystem
- modern, fully featured filesystem with very useful options for an RPi, like transparent compression and snapshots
- designed with flash memory in mind (among other things)
Here is how to do it:
I run my RaspberryPi on ArchARM linux and my card is in the SD reader, so modify those instructions accordingly for other distros and /dev interfaces.
Here is an example partition layout:
/dev/mmcblk0p1: fat32 boot partition
/dev/mmcblk0p2: to be used as btrfs partition
/dev/mmcblk0p3: to be used as btrfs partition (mirrored with the above)
/dev/mmcblk0p4 (optional): swap
To get btrfs into RAID1, you create the filesystem like so:
mkfs.btrfs -m raid1 -d raid1 /dev/mmcblk0p2 /dev/mmcblk0p3
Then you rsync -aAXv to it your previously backed up system.
To get it to boot from BTRFS in raid1, you need to modify initramfs. Therefore, you need to do the following while you still have your system running on your old filesystem.
Raspberry does not normally use mkinitcpio so you must install it. Then, you need to add “btrfs” to MODULES array in mkinitcpio.conf and recreate initramfs with
mkinitcpio -g /boot/initrd -k YOUR_KERNEL_VERSION
To know what to type instead of YOUR_KERNEL_VERSION, run
ls /lib/modules
If you update the kernel, you MUST recreate initramfs BEFORE you reboot.
Then, you need to modify RPi’s boot files.
In cmdline.txt, you need to have
root=/dev/mmcblk0p2 initrd=0x01f00000 rootfstype=btrfs
and in config.txt, you need to add
initramfs initrd 0x01f00000
Once you’ve done all that and successfully booted into your btrfs RAID1 system, the only thing left is to set up periodic scrub (every 3-7 days) either with systemd timer (preferred), or cron (dcron) like so:
btrfs scrub start /
It will run on your filesystem comparing checksums of all the files and fixing them (replacing with the correct copy) if it finds any corruption.
The combination of BTRFS RAID1, single medium and Raspberry Pi make this pretty arcane stuff. It took some time and work to put all the pieces together, but here it is.
I would go another way and would just use a read-only filesystem. I never get my raspberry pi stable enough when using a read-write root filesystem on the sdcard. You can either just boot your root via kernel cmdline (ro) or use a initramfs with piggyback including your complete system.
Both are possible to create with my homemade build system OpenADK. (http://www.openadk.org)
Well flash storage is more desirable than magnetic storage, for multiple reasons, but for this application I'll say mainly because there is no moving parts. That being said, I don't think there is a 'corruption proof' filesystem out there, but there are some robust filesystems (ext4 being one) out there, as well as some tactics to help mitigate corruption.
RAM Disk
If the RPi's image does not have to change, and it sounds like it doesn't, if nothing will try to (or should be trying to) write to the disk, then try using a root filesystem created to be unpacked into RAM. The idea here is that you have a compressed root filesystem on boot up that gets unpacked into RAM. All changes occur to the RAM disk, so there is effectively zero writing to the SD Card, only reading at boot. this should cut down on the reads/writes to your drive, preserving the life of it. This is similar to what's done when you boot linux from a CD, and is one of the first things that happens when linux boots.