SSD Nodes Learn Hosting plans →
How to do am Matt ConnorBy Matt Connor · Updated 2026-11-08

RAID 10 for VPS Storage: Wetin E Mean

Learn wetin RAID 1, 5, 6 and 10 fit survive, rebuild cost, and why VPS hosts choose RAID 10 for NVMe. Check /proc/mdstat, but no treat RAID as backup.

Wetin RAID 10 be, and why VPS hosts dey use am

RAID 10 na the storage layout wey most VPS hosts dey run for virtualised NVMe (non-volatile memory express) drives. For the normal two-copy layout, e mirror every drive to one partner, then stripe data across those mirrored pairs. One drive fit fail without the array stopping, and repair na simple copy from the partner wey still dey work, instead of recalculation wey go read every other drive for the set.

RAID mean redundant array of independent disks. E get one job: make the machine continue serving while disk dey dead or dem dey replace am. That job na availability, and availability no be safety.

RAID dey replicate your writes. rm -rf /srv na write. Both sides of the mirror fit drop the directory for the same millisecond, and the array still go report say e clean afterwards.

Keep that sentence. The rest of this page explain wetin each level fit survive and wetin each one dey cost you for every write. The last sections get the commands wey you fit use read array status for machine wey you own, plus the failure wey RAID never cover.

Levels wey hosting buyer really go meet: 1, 5, 6 and 10

Plan page fit name one number and stop there. The number answer two questions: how many drives fit fail, and wetin every write go cost.

RAID 1 na mirror. Two drives hold the same blocks. Every write go both drives. Either drive fit serve read. One drive fit fail without data loss, and half of the raw capacity dey usable. No parity dey to calculate, so write path short.

RAID 5 na striping with one parity block for each stripe. With n drives, you get capacity of n-1 drives, and the array fit survive exactly one failure. Parity no dey one dedicated drive. E dey rotate across all of dem, so every drive carry both data and parity.

RAID 6 add one second, independent parity block to every stripe, usually dem dey write am as P and Q. E fit survive any two drives failing at the same time. This matter pass as e sound, because the second failure most times happen while dem dey repair the first one.

RAID 10 na stripe of mirrors. Dem mirror drives in pairs, then spread data across the pairs. Usable capacity na half of the raw total, same as RAID 1, with striping parallelism added.

You go also see am written as RAID 1+0, and na the correct description: mirror first, then stripe across the mirrors. RAID 0+1 na the other order: stripe first, then mirror the two stripes. E worse, because one drive failure take one whole stripe out of service, and the repair must copy the entire other side.

Linux na special case wey good to know. The kernel's raid10 na one personality instead of two stacked layers, so e fit run on odd number of drives and e get layouts (near, far, offset) wey nested setup no fit express. Na why status line for Linux box dey say 2 near-copies instead of naming two arrays.

ChartEight 1 TB drives: usable capacity and drives lost before data loss
Di data wey dey behind dis chart
[
  {
    "label": "RAID 1 (eight copies)",
    "usable_tb": 1,
    "worst_case_drives_lost": 7,
    "best_case_drives_lost": 7
  },
  {
    "label": "RAID 5",
    "usable_tb": 7,
    "worst_case_drives_lost": 1,
    "best_case_drives_lost": 1
  },
  {
    "label": "RAID 6",
    "usable_tb": 6,
    "worst_case_drives_lost": 2,
    "best_case_drives_lost": 2
  },
  {
    "label": "RAID 10",
    "usable_tb": 4,
    "worst_case_drives_lost": 1,
    "best_case_drives_lost": 4
  }
]

Eight 1 TB drives give 7 TB usable space under RAID 5 and 4 TB under RAID 10. That difference na real money, and na why people keep proposing parity. RAID 6 fit survive 2 failures in any pattern at all. RAID 10 guarantee only 1, because the dangerous second failure na the one wey happen to the partner of the drive wey don already fail. E fit survive up to 4 when no two failures share one pair, but na luck, no be design property.

Wey each level cost for every write

A write to a mirror na two writes, and dem go out at the same time to both members. A write to a parity stripe na more work, because the parity block for that stripe don spoil and dem must calculate am again.

For read-modify-write, the controller first reads the old data and old parity. One uncached single-block overwrite for RAID 5 then become read, read, write, write. RAID 6 dey keep two parity blocks, so read-modify-write become read, read, read, write, write, write. Linux still dey use reconstruct-write, where e reads unchanged data to calculate parity. For three-drive RAID 5, that overwrite fit take one data read and two writes; for four-drive RAID 6, one data read and three writes. Four and six na read-modify-write counts, no be fixed cost for every small random write.

ChartUncached single-block read-modify-write operations, and drives read during a full rebuild
Di data wey dey behind dis chart
[
  {
    "label": "RAID 1 (2 drives)",
    "write_ops_per_host_write": 2,
    "drives_read_to_rebuild": 1
  },
  {
    "label": "RAID 5 (8 drives)",
    "write_ops_per_host_write": 4,
    "drives_read_to_rebuild": 7
  },
  {
    "label": "RAID 6 (8 drives)",
    "write_ops_per_host_write": 6,
    "drives_read_to_rebuild": 7
  },
  {
    "label": "RAID 10 (8 drives, fixed mirror pairs)",
    "write_ops_per_host_write": 2,
    "drives_read_to_rebuild": 1
  }
]

One uncached single-block read-modify-write cost 6 device operations for RAID 6, compared with 2 for the same overwrite on two-copy RAID 10. These counts no show the full latency difference. The two mirror writes go out in parallel, so the guest dey wait for the slower one. The read-modify-write path get one read wey must finish before the new parity fit calculate, so the guest dey wait for a read, then a write, one after the other. For a busy host, that read go queue behind other people I/O.

One important exception dey. A write wey big enough to fill one whole stripe no need old data, because every block for the stripe dey replace. The system calculates parity from wetin already dey memory, and the overhead reduce to one parity write per stripe for RAID 5 or two for RAID 6, with no prereads. Na why RAID 5 fit look okay for sequential benchmark but perform badly under mixed load of small writes from plenty tenants. Test the pattern wey you actually dey run: how to benchmark VPS disk properly means random I/O at realistic queue depth, no be one large dd.

Wetin make rebuild dangerous

A full RAID 5 rebuild must reconstruct the missing drive from every other drive. So e go read 7 surviving drives from the first block reach the last one for the eight-drive example. With fixed two-copy mirror pairs, RAID 10 rebuild reads 1: the dead drive mirror partner, and nothing else. Other Linux RAID10 layouts dey spread the copies differently. To rebuild one member of the three-device near layout, e reads both surviving members.

Two costs dey follow from this. The first one na time. The rebuild speed depends on the surviving drives, reconstruction work, and recovery speed targets. The second one na load. Parity rebuild spreads I/O across the surviving drives. With fixed mirror pairs, RAID 10 rebuild concentrates that I/O on one pair. But shared controller and host resources still affect the other pairs.

Correctness risk dey inside this same period. RAID 5 array wey get one dead drive no get redundancy again. So if any sector for a surviving drive no fit read, you no fit recover am. Rebuild na the one operation wey reads every sector, including sectors wey nobody don touch for one year. Published datasheet figures put consumer hard drive near one unrecoverable read error for every 10^14 bits read, and enterprise NVMe drive at one for every 10^17 or better. These figures na vendor specifications, no be measurements. But the ratio explain why the old warning say RAID 5 rebuild go fail come from large spinning disks, and why that warning no strong as much for NVMe. The load argument still apply to any storage medium.

Use scrubbing to find hidden errors before rebuild find dem. Debian and Ubuntu dey ship periodic scrub for md arrays. The mechanism dey differ between releases, so check which one you get, then trigger one pass by hand.

systemctl list-timers --all | grep -i mdcheck
ls -l /etc/cron.d/mdadm
echo check | sudo tee /sys/block/md0/md/sync_action
cat /sys/block/md0/md/mismatch_cnt

sync_action go back to idle when the pass finish, and mismatch_cnt suppose read 0. If a mirror get number above zero, the two halves no agree. The kernel no fit tell which one correct because neither copy get checksum. Some mismatches no cause harm. Swap partitions na the usual source: kernel fit write a page wey changes underneath am. If count dey rise for a data array, investigate am. The count alone no tell you which drive to replace.

Why VPS providers dey standardise on RAID 10 for NVMe

A hypervisor node no dey run one workload. E dey run dozens of unrelated guests, and their I/O dey arrive mixed together as stream of small writes with no locality between dem. Na this exact pattern dey make parity read-modify-write cycle cost pass, and na the pattern shared node dey handle all day.

Add the rebuild behaviour, and the choice go clear by itself. Failed drive for parity node dey add reconstruction work across the drives wey remain. With fixed mirror pairs, failed drive for RAID 10 node dey add rebuild I/O to one pair, and Linux MD dey slow recovery when other activity dey happen. Providers dey sell latency wey no spike, so dem pay for am with capacity: half of the raw NVMe dey go to the mirror.

Drive sizes dey push the choice for the same direction. As drives dey become bigger, rebuild window dey become longer. For RAID 5, na during this window reconstruction dey add load and no redundancy remain; RAID 6 still get protection against one more drive failure. Na the same reason ZFS deployments for virtualisation dey use pools of mirrored vdevs instead of wide raidz: mirror resilver dey copy only the blocks wey dey in use, for one pair.

None of this mean say RAID 10 correct everywhere. Backup target dey write in long sequential runs and dem rarely read am, so RAID 6 na better deal for there. E fit survive two failures and return most of the capacity. Na workload dey decide, no be the number. For plan wey you dey choose today, the medium usually matter pass the layout on top of am, and the jump from SATA SSD to NVMe dey bigger than any RAID difference for either one.

How to read /proc/mdstat

Run these commands for machine wey you own the array: dedicated server, box for house, or VPS with two attached volumes wey you assemble yourself. Read your own output. The blocks below na examples, and dem dey write am out so you fit match the shape of wetin you get.

cat /proc/mdstat
sudo mdadm --detail /dev/md0
lsblk -o NAME,SIZE,TYPE,MOUNTPOINTS

Healthy four-drive RAID 10 go print something close to this.

Personalities : [raid1] [raid10]
md0 : active raid10 nvme3n1p3[3] nvme2n1p3[2] nvme1n1p3[1] nvme0n1p3[0]
      3906764800 blocks super 1.2 512K chunks 2 near-copies [4/4] [UUUU]
      bitmap: 0/30 pages [0KB], 65536KB chunk

unused devices: <none>

Every part of this output get information.

  • Personalities dey list the md modules wey the running kernel don load. If raid10 dey there, e mean say the code dey available, and nothing more.
  • md0 : active raid10 na the array device, the state, and the level.
  • The names after that na the members. The number for square brackets na the device index for array metadata. E no be the position for the line, and e no always be the slot.
  • After drive replacement, the new member usually keep index wey higher than the slot wey e fill. So nvme4n1p3[4] fit dey for slot 2. mdadm --detail dey print the real slot for its RaidDevice column, so use that one when the difference matter.
  • (F) after a member mean say e faulty. (S) mean spare: e dey present, idle, and dey wait for something to fail.
  • 3906764800 blocks super 1.2 na the usable size for 1 KiB blocks, followed by the metadata format.
  • 512K chunks 2 near-copies na the stripe chunk size and the RAID 10 layout. For here, e dey keep two copies of each block beside each other.
  • [4/4] na the number of members wey the array expect, followed by the number wey currently dey in sync.
  • [UUUU] na one character for each slot, in slot order. U na slot wey dey up and dey in sync. _ na slot wey no get anything wey dey work inside.
  • bitmap: na the write intent bitmap. E dey record the regions wey dey receive writes, so member wey drop out and come back go resync only those regions instead of the whole drive.

Wetin [4/3] and [UU_U] mean when something dey wrong

Degraded array go look like this.

md0 : active raid10 nvme3n1p3[3] nvme2n1p3[2](F) nvme1n1p3[1] nvme0n1p3[0]
      3906764800 blocks super 1.2 512K chunks 2 near-copies [4/3] [UU_U]

Read the two brackets together. [4/3] talk say one out of four slots no dey contribute. [UU_U] show which one, because underscore na the third character and slots dey count from zero, so slot 2 dey down. The (F) flag name the device only while the failed drive still dey attached. Pull am out from the machine and the name go disappear from the line, while the underscore go remain.

The array go continue to serve through all this. For RAID 10, e often still serve close to full speed, so nobody go notice by feel. Something must tell you.

grep -i mailaddr /etc/mdadm/mdadm.conf
sudo mdadm --monitor --scan --oneshot --test
systemctl list-units --all | grep -i md

The mdadm package install monitor daemon wey dey read MAILADDR from /etc/mdadm/mdadm.conf. The unit name don change between releases, so find am with the last command instead of guessing. The --test run send one message for each array immediately. If inbox empty after that, the mail path dey broken, so the message wey you really care about for don get lost the same way.

When replacement dey rebuild, progress line go appear under the array.

md0 : active raid10 nvme4n1p3[4] nvme3n1p3[3] nvme1n1p3[1] nvme0n1p3[0]
      3906764800 blocks super 1.2 512K chunks 2 near-copies [4/3] [UU_U]
      [==>..................]  recovery = 12.4% (242012928/1953382400) finish=63.1min speed=452000K/sec

recovery na rebuild onto replacement drive. resync na consistency pass, including the initial pass and recovery from unclean shutdown. check na the scrub wey you trigger above. The pair for parentheses na progress for 1 KiB blocks against the per-device total, and finish na the kernel estimate at the current speed. Linux MD dey use /proc/sys/dev/raid/speed_limit_min and speed_limit_max as recovery speed targets, with per-array overrides for sync_speed_min and sync_speed_max. The default maximum target na 200,000 KiB/s per device. These targets let recovery yield to production I/O, and dem no be hard speed caps.

A full mdadm --detail during a rebuild
/dev/md0:
           Version : 1.2
     Creation Time : Tue Mar 10 09:14:22 2026
        Raid Level : raid10
        Array Size : 3906764800 (3.64 TiB 4.00 TB)
     Used Dev Size : 1953382400 (1.82 TiB 2.00 TB)
      Raid Devices : 4
     Total Devices : 4
       Persistence : Superblock is persistent

       Update Time : Wed Aug  5 11:02:41 2026
             State : clean, degraded, recovering
    Active Devices : 3
   Working Devices : 4
    Failed Devices : 0
     Spare Devices : 1

            Layout : near=2
        Chunk Size : 512K

    Rebuild Status : 12% complete

              Name : storage:0
            Events : 4184

    Number   Major   Minor   RaidDevice State
       0     259        3        0      active sync set-A   /dev/nvme0n1p3
       1     259        7        1      active sync set-B   /dev/nvme1n1p3
       4     259       11        2      spare rebuilding    /dev/nvme4n1p3
       3     259       15        3      active sync set-B   /dev/nvme3n1p3

The Number column na the metadata index wey dem print for the brackets inside /proc/mdstat. The RaidDevice column na the slot, wey be the position inside [UU_U] string. Dem differ here because device 4 replace the drive wey hold slot 2. set-A and set-B name the two halves of each mirror. So, member of set-A and member of set-B for the same pair wey dey hold the same data na the thing wey you must not lose together.

Replacing drive for array wey you own na four commands, and the last one na the check.

sudo mdadm --manage /dev/md0 --fail /dev/nvme2n1p3
sudo mdadm --manage /dev/md0 --remove /dev/nvme2n1p3
sudo mdadm --manage /dev/md0 --add /dev/nvme4n1p3
cat /proc/mdstat

The recovery line suppose appear within one or two seconds. The replacement partition must be at least as large as Used Dev Size from mdadm --detail. If partition even slightly smaller, system go reject am with message of the form not large enough to join array. Partition the new drive to match the old one before you add am.

Wetin you fit and no fit see from inside VPS

Most guests no fit see host RAID, and na so dem design am. Hypervisor dey give you one virtual disk. Whether dem carve that disk from RAID 10 pool of NVMe drives or e dey on one drive na property of the host, and e no go show inside your guest.

systemd-detect-virt
lsblk -d -o NAME,SIZE,ROTA,MODEL
cat /proc/mdstat

systemd-detect-virt dey print kvm for KVM guest, container type like lxc for container, and none for bare metal. For KVM guest, normally you go see one vda or sda inside lsblk, and no array for /proc/mdstat, because no array dey inside the guest.

For container-based VPS, you no fit trust the reading. Containers dey share host kernel, and parts of /proc no dey namespaced. So wetin you read there fit describe the host instead of your own slice. No treat any of am as fact about your own storage. Ask the provider how the layout be, and make dem give you the answer for writing if e matter to you.

Wetin you fit check from inside na how the disk wey dem give you dey behave. Check whether your VPS disk really be NVMe cover the commands wey report real information, while wetin an SSD VPS actually include cover wetin the label for the plan page dey claim.

You suppose run RAID inside your VPS?

Usually no, and the reason na failure domains. If you attach two volumes to one VPS and mirror dem with mdadm, both volumes fit dey on the same physical array, for the same node, behind the same power supply. You go double the cost of every write for redundancy wey you already get, and you still go lose both copies to the one failure wey matter.

E make sense when the provider document say the volumes dey for separate failure domains, or when you dey use dedicated server with drives wey you fit control. Otherwise, make the effort go into copies wey comot from the machine.

Wetin RAID no dey protect you from

RAID dey cover one event: drive wey stop to work correctly. Everything wey dey below na valid write, so the array go apply am to every copy and report say e healthy.

  • Deletion. rm -rf for wrong directory, or deploy script wey get unset variable for path. The array see legal write and do am twice.
  • Ransomware. Encryption na writing. Healthy array go store the encrypted version for both sides of the mirror.
  • Broken application. Bug wey write garbage inside your database go write the same garbage to the redundant drive.
  • The whole node. Host wey fail, or account wey dem suspend by mistake. Array fit dey perfect and still no dey reachable at the same time.
  • You, one week later. File wey you delete on Monday don disappear from every drive that same Monday. Na only copy wey dem take before then fit bring am back.

Snapshots for the same storage no be the fix too. Dem fit help against deletion, but dem go die with the array wey dem dey live on. The thing wey make backup be backup na say e dey somewhere else. Encrypted off-server backups with restic na the other half of this page: the array keep you serving through dead drive, while restic bring your data back when the damage na write wey the array happy to make.

FAQ

RAID 10 mean say I no need backups?

No. RAID 10 dey protect against drive wey stop to work. E dey apply every valid write to both sides of mirror at the same time, so deletion or ransomware run go reach the redundant drive for that same moment. The array go report say e clean afterwards, because from e own point of view nothing fail. You still need copies wey dey outside the machine, and you still need restore one sometimes to prove say dem dey work.

Why VPS providers dey choose RAID 10 instead of RAID 5 or RAID 6?

Two reasons, and both concern small random writes. An uncached single-block read-modify-write dey read old data and parity before e calculate new parity. This cost 4 operations for RAID 5 and 6 for RAID 6, compared with 2 for two-copy mirror. Reconstruct-write dey use unchanged data instead, and full-stripe writes no need old-data or old-parity prereads. Full RAID 5 rebuild go then read every surviving drive from beginning to end, while conventional RAID 10 with fixed mirror pairs dey copy from the surviving partner; other Linux RAID10 layouts dey use multiple source members. Linux MD dey reduce recovery speed when other activity dey happen. Providers dey pay for this with capacity: half of the raw NVMe.

Wetin [U_] or [UU_U] mean for /proc/mdstat?

Each character na one slot for the array, in slot order, with one character for each slot. U mean say that slot hold a member wey dey up and in sync. _ mean say nothing dey work for that slot. [U_] for a two drive mirror mean say the second slot dey down and redundancy no remain. Read am together with the pair wey dey in front of am, where [4/3] say the array expect four members and get three. The slot order match the RaidDevice column of mdadm --detail, not the order wey device names appear for the line.

How many drives fit RAID 10 array lose?

For conventional two-copy RAID 10 with fixed mirror pairs, one, no matter the pattern. After that, e depend on where the failures happen. Each mirror pair fit lose one of its two members, so an eight drive array fit survive up to four failures if no two share one pair. E go fail at two failures if both hit the same pair. Plan around the number wey guaranteed, which na one, and treat anything beyond am as luck, not protection.

I suppose mirror two volumes inside my VPS with mdadm?

Usually no. Two volumes wey attach to one VPS often dey live on the same physical array for the same host. So mirroring dem go double the cost of every write and protect against nothing wey the host own RAID never already cover. E worth doing only when the provider document say the volumes dey for separate failure domains. Otherwise, put that effort into backups wey leave the machine.

Dis article help you?