Introduction to Btrfs on Android Custom Kernels

Integrating advanced filesystem features into Android devices often requires delving into custom kernel development. While Android traditionally relies on ext4 or F2FS, Btrfs offers a compelling alternative with its robust feature set, including snapshots, copy-on-write, and native RAID capabilities. For power users and developers, leveraging Btrfs on Android can unlock significant performance gains, enhanced data integrity, and flexible storage management. This guide explores how to implement and optimize Btrfs with RAID0, RAID1, and various compression strategies specifically for custom Android kernels, transforming your device’s storage subsystem.

Why Btrfs for Android?

Btrfs stands out due to several key advantages:

• Data Integrity: Checksums for data and metadata ensure data consistency and detect corruption.
• Snapshots: Instantaneous, space-efficient read-only or read-write snapshots for system backups and recovery.
• RAID Support: Native support for RAID levels (0, 1, 5, 6, 10) directly within the filesystem, abstracting away traditional volume management.
• Copy-on-Write (CoW): Improves data integrity and enables features like snapshots.
• Online Resize: Filesystems can be grown or shrunk while mounted.

These features, while powerful, demand kernel-level support. Therefore, a custom Android kernel compiled with Btrfs modules is a prerequisite for this advanced tuning.

Prerequisites and Initial Setup

Before proceeding, ensure your custom Android kernel is properly configured and compiled with Btrfs support. This involves enabling specific options in your kernel’s .config file.

Kernel Configuration

Navigate to your kernel source directory and ensure these options are enabled:

CONFIG_BTRFS_FS=y
CONFIG_BTRFS_FS_POSIX_ACL=y
CONFIG_BTRFS_FS_CHECK_INTEGRITY=y
CONFIG_BTRFS_FS_RAID0=y
CONFIG_BTRFS_FS_RAID1=y
CONFIG_BTRFS_FS_RAID10=y
CONFIG_BTRFS_FS_RAID56=y
CONFIG_BTRFS_FS_COMPRESSION=y
CONFIG_BTRFS_FS_COMPRESSION_LZO=y
CONFIG_BTRFS_FS_COMPRESSION_ZLIB=y
CONFIG_BTRFS_FS_COMPRESSION_ZSTD=y

After recompiling and flashing your custom kernel, you’ll need btrfs-progs user-space tools. These can be compiled for Android (ARM/ARM64) and pushed to your device, typically to /system/bin or /vendor/bin.

# Example: Push btrfs-progs to device
adb push btrfs /system/bin/
adb push btrfs-debug-tree /system/bin/
adb push btrfs-find-root /system/bin/
adb push btrfs-image /system/bin/
adb push btrfs-map-logical /system/bin/
adb push btrfs-restore /system/bin/
adb push btrfs-scrub /system/bin/
adb push btrfs-select-super /system/bin/
adb push btrfs-zero-log /system/bin/
adb push mkfs.btrfs /system/bin/
adb shell chmod 755 /system/bin/btrfs* /system/bin/mkfs.btrfs

Implementing RAID0 for Maximum Performance

Btrfs RAID0 stripes data across multiple block devices, theoretically multiplying read/write throughput by the number of devices. This configuration offers the highest performance but comes with zero redundancy; the failure of any single device results in total data loss. It’s ideal for temporary scratch space or scenarios where raw speed is paramount and data loss is acceptable or handled by external backups.

Step-by-Step RAID0 Setup

Assume you have two unused block devices, /dev/block/sda and /dev/block/sdb (these paths are examples; always verify your device paths).

1. Identify and Zero Devices: Ensure no existing filesystem signatures interfere.

adb shell
dd if=/dev/zero of=/dev/block/sda bs=1M count=100
dd if=/dev/zero of=/dev/block/sdb bs=1M count=100

2. Create Btrfs RAID0 Filesystem:

mkfs.btrfs -d raid0 /dev/block/sda /dev/block/sdb

3. Mount the Filesystem:

mkdir /mnt/btrfs_raid0
mount -t btrfs -o ssd,noatime,compress=zstd /dev/block/sda /mnt/btrfs_raid0

Performance Considerations for RAID0

While RAID0 offers speed, be mindful of:

• I/O Bottlenecks: If your underlying storage (e.g., eMMC or UFS) doesn’t have parallel access capabilities, the gains might be limited.
• Device Speed Mismatch: Performance will be capped by the slowest device in the array.
• Metadata RAID1: Btrfs defaults to RAID1 for metadata even on RAID0 data profiles to improve resilience, which is a good safety measure.

Implementing RAID1 for Data Redundancy

Btrfs RAID1 mirrors data across two devices, ensuring that each piece of data is stored twice. This provides excellent data redundancy; if one device fails, your data remains accessible from the other. Performance for reads can be aggregated (similar to RAID0), but writes are typically slower as data must be written to both devices. RAID1 is suitable for critical user data or system partitions where data integrity is paramount.

Step-by-Step RAID1 Setup

Again, using /dev/block/sda and /dev/block/sdb as example devices.

1. Identify and Zero Devices: (Same as RAID0)

adb shell
dd if=/dev/zero of=/dev/block/sda bs=1M count=100
dd if=/dev/zero of=/dev/block/sdb bs=1M count=100

2. Create Btrfs RAID1 Filesystem:

mkfs.btrfs -d raid1 /dev/block/sda /dev/block/sdb

3. Mount the Filesystem:

mkdir /mnt/btrfs_raid1
mount -t btrfs -o ssd,noatime,compress=zstd /dev/block/sda /mnt/btrfs_raid1

Data Integrity and Recovery in RAID1

Btrfs RAID1 provides more than just mirroring:

• Self-Healing: If data corruption is detected on one mirror, Btrfs can automatically repair it using the good copy.
• Scrubbing: Regularly run btrfs scrub to check for and repair bit rot and data integrity issues across all devices in the array.

btrfs scrub start /mnt/btrfs_raid1

• Device Replacement: If a device fails, it can be replaced online using btrfs device replace, though this is a more complex operation on a live Android device.

Optimizing with Btrfs Compression Strategies

Btrfs supports inline compression, which can significantly save disk space and, in some cases, improve performance by reducing the amount of data read from/written to physical storage. However, it introduces CPU overhead. The key is choosing the right algorithm.

Choosing the Right Algorithm

• zstd (Zstandard): Generally the best all-rounder. Offers excellent compression ratios and very fast decompression, often outperforming zlib and lzo in real-world scenarios. Recommended for most use cases on modern CPUs.
• zlib: Good compression ratio, but slower than zstd for both compression and decompression. A safe choice if zstd isn’t available or preferred.
• lzo: Fastest compression and decompression, but with the lowest compression ratio. Ideal for scenarios where CPU cycles are extremely limited and I/O speed is paramount.

Enabling Compression

Compression can be enabled filesystem-wide at mount time, or per-file/directory.

1. Mount-time Compression: This applies compression to all new data written to the filesystem.

# For zstd
mount -t btrfs -o ssd,noatime,compress=zstd /dev/block/sda /mnt/btrfs_volume

# For zlib
mount -t btrfs -o ssd,noatime,compress=zlib /dev/block/sda /mnt/btrfs_volume

# For lzo
mount -t btrfs -o ssd,noatime,compress=lzo /dev/block/sda /mnt/btrfs_volume

2. Per-File/Directory Compression: You can apply compression to existing files or specific directories.

# Enable compression on a file (new writes will be compressed)
chattr +c /mnt/btrfs_volume/my_document.txt

# Enable compression on a directory (new files in it will be compressed)
chattr +c /mnt/btrfs_volume/photos/

# Recompress existing data (useful after changing mount options or 'chattr')
btrfs filesystem defragment -r -v -c zstd /mnt/btrfs_volume/

Performance Impact and Benchmarking

While compression can reduce I/O, the CPU overhead must be considered. On low-power Android CPUs, aggressive compression might lead to higher CPU usage, potentially offsetting I/O gains. Benchmark your specific workload using tools like iozone or fio to determine the optimal compression algorithm and settings for your device.

# Example: Basic fstrim/discard (essential for SSD/eMMC performance)
fstrim -v /mnt/btrfs_volume

Advanced Tuning and Maintenance

Mount Options Revisited

Beyond compression, other mount options are crucial for performance and longevity on Android’s flash storage:

• ssd: Optimizes internal Btrfs data structures for SSDs/eMMC, improving wear leveling and performance.
• noatime: Prevents update of access times on files, reducing write amplification.
• space_cache=v2: Uses an improved, more robust space cache format, generally faster.
• commit=N: Sets the transaction commit interval (in seconds). A lower value (e.g., commit=5) reduces data loss risk on sudden power off but increases write frequency.

mount -t btrfs -o ssd,noatime,compress=zstd,space_cache=v2,commit=5 /dev/block/sda /mnt/btrfs_volume

Balancing and Scrubbing

• Balancing: Btrfs uses a metadata balancing mechanism to distribute data evenly and optimize space. Periodically running btrfs balance can improve performance, especially after significant data changes or adding/removing devices.

btrfs balance start /mnt/btrfs_volume

• Scrubbing: As mentioned for RAID1, scrubbing is vital for data integrity across all Btrfs configurations. It reads all data and metadata, verifies checksums, and attempts repairs if necessary.

Conclusion

Btrfs, when properly configured within a custom Android kernel environment, offers an unparalleled level of control, performance, and data integrity for your device’s storage. By strategically implementing RAID0 for speed, RAID1 for redundancy, and fine-tuning compression algorithms like Zstd, you can tailor your Android device’s storage to specific needs. Remember that thorough testing and understanding the trade-offs between performance, redundancy, and CPU overhead are key to unlocking Btrfs’s full potential on mobile platforms.