Reed-Solomon error recovery in RAID-6

http://anadoxin.org/blog/error-recovery-in-raid6.html/

by signa11 • 6 years ago

101 32 6 years ago

anadoxin.org

layoutIfNeeded2• 6 years ago

Edit: I was wrong

bfuclusion• 6 years ago

Correct me if I'm wrong, but I think that scheme will protect you from at most one erasure.

Fail D1 and P1 There's no way to recover D1s data since P2 has no data from D1 in it.

layoutIfNeeded2• 6 years ago

Actually, you're right!

jakubp• 6 years ago

There is no mention of "P1" in the entire article. What did you mean?

eps• 6 years ago

There's also this paper, which is quite good -

https://mirrors.edge.kernel.org/pub/linux/kernel/people/hpa/...

Also there are simpler, xor-based encoding schemes that allow recovering from double failures (e.g. EvenOdd and such), but the problem is that they are all patented.

est31• 6 years ago

This E-Mail about increased numbers of parities is also interesting: https://www.mail-archive.com/linux-btrfs@vger.kernel.org/msg...

huhtenberg• 6 years ago

That's the SnapRAID dev!

Also, check out this bit -

  >> Could you perhaps describe how the Cauchy matrix is 
  >> derived, and under what conditions it would become
  >> singular?

  > The Cauchy matrix has the mathematical property ...
  > ...
  > Besides the mathematical proof, I've also inverted all 
  > the 377,342,351,231 possible submatrices for up to 6 
  > parities and 251 data disks, and got an experimental 
  > confirmation of this.

"Trust, but verify" :)

[0] https://www.mail-archive.com/linux-btrfs@vger.kernel.org/msg...

miahi• 6 years ago

The talk about striping (the fact that all the disks contain both data and the two levels of parity) is glossed over, but what it means is that there are not 7 types of failure/recovery, there are just two - when one drive fails, and when two drives fail. And the recovery actually contains all cases all the time (case 1-3 for 1 disk, case 4-7 for two disks).

redis_mlc• 6 years ago

I'm a storage engineer.

There's a huge difference bewtween theory and practise.

- rebuilds can timeout

- load can really cause timeouts

- raid controllers can have tested modes that work, and some that don't

- batches of drives can all fail at the same time, esp. during rebuilds

- the nvram might not be portable across controllers.

mchristen• 6 years ago

More than once I've lost a RAID array during a rebuild. That's what backups are for, I suppose.

sliken2• 6 years ago

1st lesson on using a RAID should be that RAID is not a replacement for backups.

klodolph5• 6 years ago

This is to be expected. RAID 5 is not safe. It is common for a RAID 5 array to be running in a degraded state during “normal” operation without the operator’s knowledge. Then, when one drive fails, rebuilding the array is impossible; you have already lost data.

This is common because there is often no good way to repair a RAID 5 system which is running in degraded state, and there is often no monitoring to respond to array degradation (if you can’t fix it, why monitor it?)

In other words, RAID 5 does not protect very well against drive failures. RAID 6 is more durable but inefficient (there are systems which are both more durable and more efficient than RAID 6). RAID is generally optimized for implementation simplicity over other concerns.

alanfranz• 6 years ago

Is there any system for error recovery in userspace? Something like, I’ve got directory DATA, i want to create a recovery file for all the contents in such directory. Ideally I’d like to be able to tune the size of the recovery, larger recovery = recover more errors

auxym• 6 years ago

We used to use this when creating backups on CD-Rs and later DVDs, before hard drives became cheap...

https://en.wikipedia.org/wiki/Parchive

bestham• 6 years ago

I used a program named Dvdisaster for the same use case. You could use it I two modes: (1) One disc with additional out of band reed-solomon ECC. Create an iso that are smaller by a certain percentage than the medium you want to burn it to. Dvdisaster will create a new ISO that uses the full capacity of the medium and fill the remaining space with parity-information that protects the whole file system and all user files. (2) Put your parity information on the next disc you burn. A parity file is crated for the first disc you burn, this is later added to the file system of the second disc you burn. Repeat indefinitely. You always have the last yet-to-be-burned parity file on your computer and can thus recover bit-errors in every disc you have burned.

dylan6042• 6 years ago

We used to use this in Newsgroup days. Large files got broken into smaller chunks (maybe floppy disk sized??) in the RAR format. You could recover missing files if they expired before you get them downloaded on your dial-up modem or your particular newsgroup service wasn't reliable enough.

dmayle• 6 years ago

What you're looking for is called Parchive. It uses Reed-Solomon coding in order to generate redundant files that can be used to recover the original. Look for PAR2 utilities (the current major version of the format). It has multiple implementations, open source and closed, across platforms and architectures.

https://en.wikipedia.org/wiki/Parchive

brnt• 6 years ago

I wrote a gui for it, tot help deal with many files being in various states: https://github.com/brenthuisman/par2deep

thomasmg• 6 years ago

Another option is to use an IBLT (Inverted Bloom Lookup Table). it is easy to implement. I recently wrote a file repair tool that uses it: https://github.com/thomasmueller/tinyStats/blob/master/src/m... (not production ready)

sliken2• 6 years ago

This isn't a turn key utility, but it's relatively easy to call from Go. It allows you to set the number of data shards and parity shards, it's pretty fast. It's at

  https://github.com/klauspost/reedsolomon

Seems like a pretty common solution, I suspect there's other libraries for popular language/platforms.

dragontamer5• 6 years ago

On the one hand, this is a great "brute force" method to learn how one implementation of RAID6 could happen. This blogpost achieves understanding of error-correction in the 2-parity case through brute force alone, and that's actually quite commendable.

On the other hand, its a very, very bad way to learn Reed Solomon codes. Reed Solomon codes "in general" are a concept that's broader than just 2-parity symbols... and also broader than just "protection vs erasures". Reed Solomon is designed to correct errors as well (a far "harder" computation than simply an erasure).

I've fortunately found a good "ELI5" version of Reed Solomon: https://www.youtube.com/watch?v=xE4jEKx9fTM

That's a very non-technical talk, but that talk gives the full concepts of "Polynomial in Finite Field" that Reed Solomon codes are based off of.

For a proper computer-based Reed Solomon code, you choose the GF(2^8) extension field for 8-bit symbols (Pararchive uses 2^16 for 16-bit symbols). Extension fields are extremely complicated to understand however, this will take a few days of Abstract Algebra study to understand how extension fields work.

But once you know how a finite extension field works, you then extend a polynomial into the extension field, and bam, you have Reed Solomon codes.

That is: a Quadratic equation can protect 3-data. All quadratic equations are ax^2 + bx + c, so any 3-points define a quadratic equation. Generate (x,y) coordinates on a graph as (0, data0), (1, data1), (2, data2).

Then, solve for a quadratic equation f(x) = ax^2 + bx + c.

Then, to generate parity, f(3) is your first parity symbol, f(4) is your next parity symbol, f(5) is the parity symbol after that. Etc. etc. Note in a 8-bit finite field, you can only go up to f(255) before "looping back" to f(0).

From there: 2-check symbols will protect against either 2-erasures or 1-error. So Quadratic Equation with 4-check symbols (aka: 4 "other points" of the quadratic equation passed with the data) can protect against 4 erasures... or 2-errors, or 2-erasures + 1 error.

klodolph5• 6 years ago

Note that the size of the field only has to be as large as the size of the redundancy set (data + code). So if you are striping across 16 or fewer disks, you can use GF(2^4), but if you are striping across 17 disks you can’t use GF(2^4).

Well, if I remember the math correctly.

dragontamer5• 6 years ago

Well, if I remember the math correctly.

You're off by one. There's a "minus 1" because Reed Solomon is over the cyclical multiplication group, not over the cyclical additive group. (TL;DR: The number 0 cannot participate in... some portion of the formulation of the polynomials)

GF(2^3) is over blocksize of 7. GF(2^4) is over blocksize of 15. GF(2^8) is over 255.

---------

GF(2^8) is the smallest size in practice, because most people's data is organized into 8-bits-at-a-time today. (aka: a byte). But you're mostly right (once you account for the off-by-one error): there's a limit to 255 elements per block in GF(2^8) Reed Solomon.

But GF(2^3) or GF(2^4) are great for hand-exercises, the smaller size makes it far easier to compute calculations by hand and allow for the human to gain understanding. (aka: Octal 2^3 numbers or Hexadecimal 2^4 numbers). GF(2^2) is technically possible... but all the matrix math is over 1x1 matricies and not really a good opportunity to learn from. GF(2^1) is literally impossible for Reed Solomon to work in. So GF(2^3) is the smallest practical hand-exercise size (RS(7, 5) over GF(2^3) has a 5x7 generator matrix and a 7x2 check matrix. Small enough to do by hand though a bit tedious).

If you actually wanted to "split symbols up" so that you better detect bit-errors, then LDPC or Turbocodes are straight up superior over Reed Solomon for "small symbol sets". Reed Solomon is best used over "large symbols" (aka: 2^8 or larger).

----------

Any Reed Solomon code can be punctured (aka: fewer parity symbols), or shortened (aka: fewer data symbols) by simply setting locations of the Reed-Solomon generator and/or check matrix to 0.

As such, if you organize "smaller sets" into 2^8 (aka: 8-bit bytes), its just very natural to use a punctured + shortened Reed Solomon code instead of trying to get a 2^4 Reed Solomon code to work.

Reed-Solomon error recovery in RAID-6

Related Stories