Learn RAID - Software vs Hardware vs Firmware RAID

#Introduction

In episode 2 you understood the RAID levels. The next question: where is RAID computed and run? The answer determines everything — from array portability and performance to how you handle failures. Episode 3 compares three paths: software RAID, hardware RAID, and firmware RAID.

These three paths often confuse beginners, especially when buying a board or server that claims to "support RAID". In reality, many motherboard built-in RAID modes are fake RAID that actually cause more trouble. Let's break them down one by one so you can choose with your eyes open.

#Software RAID with the Kernel MD and mdadm

#How It Works and Its Advantages

Software RAID leverages the kernel MD driver, already integrated into Linux. All parity and striping calculations are done by the CPU, while mdadm acts as the tool to create, assemble, and monitor arrays. This is the path we'll use for most of this series.

Main advantages of software RAID:

• Portable: array metadata can be read across distributions; the array can be assembled on another machine as long as the kernel supports MD.
• No hardware lock-in: not tied to a specific vendor controller.
• Free and flexible: you can change levels, add disks, and use features such as write-intent bitmap.

Its weakness is boot complexity: you need to make sure the initramfs loads MD and reads mdadm.conf before the root filesystem is mounted.

grep -i raid /proc/mdstat
lsmod | grep raid

The /proc/mdstat output shows the list of arrays and modules such as raid1, raid5, or raid10 that are currently active.

#When to Choose It

Software RAID is the best choice for homelabs, Linux servers, and almost every common workload. Its performance on SATA disks and even SSDs is quite good because modern CPUs have no trouble computing parity. For most readers of this series, the answer to "software or hardware" is software — and we'll build all subsequent practice on this choice.

#Hardware RAID with a Controller Card

#How It Works and Its Advantages

Hardware RAID moves all the work to a controller card with its own processor and cache. The operating system only sees a single logical disk; parity, striping, and rebuilds are handled entirely by the card. Many cards also have a battery backup unit (BBU) or supercapacitors so that the write cache stays safe during a power outage.

Advantages of hardware RAID:

• OS-independent: the driver only needs to understand a single logical disk.
• Battery-backed write cache: writes can complete in cache and then be flushed to disk efficiently.
• High parity performance on certain workloads thanks to a dedicated processor.

#Drawbacks and Risks

The biggest drawback of hardware RAID is vendor lock-in. If the card fails, you must buy the same or a compatible card to read the array — this often becomes a nightmare when the vendor discontinues the product. In addition, the battery or supercapacitor can die, causing the write cache to fall back to write-through mode with a severe performance drop, or even risking loss of data still sitting in cache.

sudo storcli /c0 show

The storcli command is an LSI/Broadcom vendor tool for reading logical drive configuration and cache status. Similar tools exist for other adapters and are usually available from vendor packages. If you don't have such a card, there's no need to memorize it — the important thing is to understand the concept.

#Firmware RAID (Fake RAID)

#What Are IMSM and DDF

Firmware RAID, often nicknamed fake RAID, is a built-in RAID mode in consumer controllers such as Intel chipsets. The array configuration is stored in metadata on the disks — commonly in IMSM (Intel Matrix Storage Manager) format for Intel chipsets or DDF (Disk Data Format) as an industry standard. At boot, the firmware loads the metadata and presents the array as a logical disk.

Its drawback: it doesn't actually compute parity in hardware — the work is still done by the CPU through a driver, but without the convenience and portability of full software RAID. IMSM/DDF arrays generally can only be assembled with tools that support that format.

#Our Recommendation

Our recommendation for you: avoid fake RAID for production. If the board only offers this mode, it's better to set the disks to AHCI/RAID-off mode and build the array with mdadm — the result is more portable, more transparent, and doesn't lock you into a specific chipset.

sudo mdadm --examine /dev/sdb

The output of mdadm --examine /dev/sdb shows the array metadata on a disk. For fake RAID disks, modern mdadm can detect IMSM and DDF formats and warn you.

#Quick Comparison

Your biggest decision is choosing between software and hardware RAID. For the majority of cases in this series and in real practice, software RAID with mdadm and ZFS is the most sensible answer.

#Workloads That Need Hardware RAID

There are a few exceptions. Workloads with very high synchronous writes in Windows environments, or large-scale deployments already tied to a specific card ecosystem, still commonly use hardware RAID. However, in the modern Linux world, the combination of mdadm, ZFS, and LVM has closed almost all of the performance gap — while giving you far greater control.

#Conclusion

Episode 3 explained that where RAID is computed determines your portability and risk. Software RAID with the kernel MD and mdadm is flexible and lock-in free; hardware RAID offers battery-backed cache but ties you to a vendor; fake RAID IMSM and DDF are traps best avoided for production.

Key takeaways:

• Software RAID uses the CPU, is portable, and is recommended for most cases.
• Hardware RAID has battery-backed cache but is prone to vendor lock-in.
• Fake RAID IMSM and DDF store metadata on the disks and are limited in capability.
• Check disk metadata with mdadm --examine to know the array format.
• For production, build arrays with mdadm rather than the chipset's built-in RAID mode.
• Modern Linux closes almost all of the performance gap with hardware RAID.

In the next episode, episode 4, we'll discuss mdadm create & assemble array — creating your first array with --create, understanding metadata from 0.90 to 1.2, and making sure the array assembles automatically at boot via mdadm.conf. This is your first step toward full control over the array.