RAID & ZFS Capacity Calculator

About the RAID & ZFS Capacity Calculator

Enter your drives, how many and how big, and choose a layout to see the usable capacity in TB (as drives are sold) and TiB (as Windows, ZFS and df -h count), how many drives can fail, how fast the array reads and writes compared with one drive, and how long a rebuild takes. It covers RAID 0, 1, 5, 6, 10, 50 and 60, ZFS mirror vdevs and RAID-Z1, RAID-Z2 and RAID-Z3, and compares every layout for the same drives side by side.

Mixed drive sizes are worked out the way arrays really behave: traditional RAID uses only the smallest drive’s size on every member, and ZFS the smallest drive of each vdev, so the calculator shows what is lost and how to avoid it. For ZFS it also works out what zfs list will show, including RAID-Z padding and the space ZFS keeps in reserve: the reasons a pool often shows less than (drives − parity) × size.

RAID is not a backup. It keeps data available when a drive fails, but deleted or overwritten files, ransomware, corruption, theft and fire reach every drive of the array at once.

Without a pass the result is a free preview: the usable capacity in full, with the first rows of each table and a watermarked drive map; every other figure is hidden. The full results, copying the summary and the CSV unlock with a Pro pass.

Common uses

• Sizing a home or small-office NAS before buying the drives.
• Choosing between RAID 5, RAID 6 and RAID 10, or RAID-Z1, RAID-Z2 and mirrors, for space, safety and speed.
• Explaining why the operating system or zfs list shows less space than the drives add up to.
• Planning a drive replacement: how long the rebuild runs and how exposed the array is meanwhile.
• Checking a server or storage quote: the usable space of each layout for the same set of drives.

How usable capacity is worked out

With N drives of size X (after any hot spares):

• RAID 0: N × X, with no protection.
• RAID 1: X; every drive holds a copy.
• RAID 5: (N − 1) × X. RAID 6: (N − 2) × X.
• RAID 10: N × X ÷ w with w-way mirrors (usually 2).
• RAID 50 and RAID 60: s × (k − 1) × X and s × (k − 2) × X for s spans of k drives.
• ZFS mirror vdevs: X per vdev. RAID-Z1, Z2, Z3: about (k − P) × X per vdev of k drives with P parity drives (OpenZFS zpoolconcepts).

Traditional RAID gives every member the same share, so a larger drive contributes only as much as the smallest one; Linux md RAID 0 is an exception and keeps striping over the larger drives (md(4)). ZFS counts the drives of each vdev as the smallest drive of that vdev, so the calculator groups the largest drives together. A RAID 10 drive count that is not a multiple of the mirror width follows Linux md’s default “near” layout, which md accepts; classic RAID 10 is a stripe of whole mirrors, so check that your controller or NAS accepts such a count.

TB versus TiB

Drive makers sell capacity in decimal units: 1 TB is 1,000,000,000,000 bytes. Windows, ZFS and df -h count in binary units, where 1 TiB is 2⁴⁰ = 1,099,511,627,776 bytes, and often label them “TB” or “T”. The bytes are the same; only the unit differs, so an 8 TB drive shows as about 7.3 TiB (Seagate on decimal and binary capacity, NIST binary prefixes, GNU df block sizes). Every figure here is shown in both.

What ZFS reports: padding and the reserve

RAID-Z stores each block in whole sectors: its data sectors, P parity sectors for every row of (k − P) data sectors, and padding so that the total is a multiple of P + 1 (vdev_raidz.c). ZFS reports pool space as if every block were 128 KiB (vdev.c), so a width that does not split 128 KiB evenly shows less than (k − P) × X. With 4 KiB sectors an 8-drive RAID-Z2 stores a 128 KiB block in 45 sectors instead of the ideal 42.7, about 5% less, while a 6-drive RAID-Z2 loses almost nothing. The block-size table shows the split for your layout.

ZFS also holds back 1/32 of every pool, at most 128 GiB, so that a pool never fills completely (spa_slop_shift in zfs(4), spa_misc.c). zpool list shows the raw size, parity included for RAID-Z; zfs list shows what datasets can use (zpoolprops). Blocks smaller than 128 KiB, such as small files, databases and zvols with a small block size, take relatively more parity (OpenZFS on RAIDZ); larger records take a little less, as the block-size table shows.

Fault tolerance and the odds of surviving more failures

“Any 2 drives can fail” is the guarantee: the worst case. Layouts made of several groups (RAID 10 mirrors, RAID 50 and 60 spans, several ZFS vdevs) survive more failures when they land in different groups, so the calculator also shows, for up to three failures more than the guarantee, the share of all combinations of that many drives failing at once that the array survives, counting every drive as equally likely to fail. With 8 drives in RAID 10, two failures are fatal only when they are both drives of one mirror: 4 of the 28 possible pairs, so 86% of pairs are survived.

Failures are not always independent: drives of the same age and batch share their wear, and a rebuild loads every remaining drive. Plan on the guarantee, not the odds.

Rebuild time and read errors

Traditional RAID rebuilds the whole replacement drive however much data the array holds, so the time is about the drive size divided by the rebuild speed: 8 TB at 100 MB/s takes 22 h 13 min. ZFS resilvers only the data in use, so the time is proportional to how full the pool is (Oracle ZFS administration guide on resilvering). The speed is an assumption you set: a drive’s sustained speed from its datasheet is the best case, and a busy array rebuilds slower. Linux md, for example, aims for as little as 1,000 KiB/s per drive while other I/O competes, and for at most 200,000 KiB/s per drive by default (md(4)).

Until a single-parity array (RAID 5, RAID 50, RAID-Z1 or a 2-way mirror) has rebuilt, it has no redundancy left, and every sector the rebuild reads must read cleanly. Drive datasheets state a non-recoverable read error rate as one error per so many bits read, for example 1 per 10¹⁵. The calculator shows the chance of at least one such error over the data the rebuild must read, 1 − (1 − 10⁻ᵉ)ⁿ for n bits, which assumes independent errors at exactly that rate: a deliberately cautious figure, not a forecast. With dual parity (RAID 6, RAID-Z2) such an error during a single-drive rebuild is still corrected.

Performance: what the multiples mean

The figures are theoretical limits in multiples of one drive, before controllers, caches, the CPU or the network get in the way:

• Streaming read and write: large transfers spread over the data drives; parity adds nothing to streaming speed.
• Random reads: every drive can serve reads, except in RAID-Z: a 128 KiB block is spread over the whole vdev, so each RAID-Z vdev gives roughly the random-read IOPS of one drive (OpenZFS on RAIDZ).
• Random writes: a small write costs 4 disk operations on RAID 5 (read the data and parity, write both) and 6 on RAID 6; a mirror writes every copy. RAID-Z writes full stripes, with no read-modify-write, but a RAID-Z vdev gives about the random-write IOPS of its slowest drive.
• Mirror reads: a range such as 2–4× means that one large stream reads from one drive per mirror, while many readers at once can use every drive. Linux md RAID 1 reads a single stream from one drive (md(4)).

Enter one drive’s speed and IOPS to turn the multiples into estimates. The mixed figure counts disk operations: random IOPS ÷ (reads + writes × the write penalty).

RAID is not a backup

RAID protects against a drive failing, and nothing else. A deleted or overwritten file, ransomware, a faulty controller or firmware, a power surge, theft, fire or flood affect every drive of the array at once, and further failures during a rebuild can take the whole array. Keep at least one separate copy of anything you cannot lose, ideally one off-site or offline, and test restoring from it. ZFS snapshots help against deletion and ransomware on the pool itself, but they live on the same drives.

Limitations

• Performance figures are theoretical; real speed depends on the controller, cache, CPU, file system, network and workload.
• Not modelled: RAID 1E, RAID 5E and 5EE, ZFS dRAID, Synology Hybrid RAID (SHR), Unraid, Btrfs RAID profiles and Windows Storage Spaces.
• Controllers, Linux md and ZFS keep a little space for their own metadata and labels, and ZFS rounds each vdev to whole metaslabs, so a real array shows slightly less.
• RAID 10 with a drive count that is not a multiple of the mirror width uses Linux md’s near layout; its far and offset layouts place copies differently.
• ZFS figures leave out compression and the special, log and cache vdevs; after RAID-Z expansion, blocks written earlier keep their old data-to-parity ratio.
• The read-error chance and the survival odds treat errors and failures as independent and every drive as equally likely to fail.
• Up to 1,000 drives and 12 rows of drive sizes; the drive map draws up to 60 drives.

Privacy

On this device: nothing is sent

Everything happens in your browser. What you enter or open here is not uploaded or stored by MySmartCoPilot.