RAID Reconstructor no es compatible directamente con matrices RAID-6, por lo que no recuperará automáticamente una configuración RAID-6. Sin embargo, con algunos conocimientos sobre su RAID-6, puede crear una imagen virtual (archivo VIM) que le permita reconstruir el RAID-6 tras el fallo de hasta dos unidades. Toda nuestra gama de software de recuperación de datos es compatible con imágenes virtuales. Una vez que haya creado un archivo VIM, puede utilizarlo para montar, clonar, crear una imagen o recuperar datos de su RAID-6 reconstruido. En este momento, las siguientes versiones de software son compatibles con archivos VIM para RAID-6: DiskExplorer X V2.01, GetDataBack Pro V5.63, RAID Reconstructor V5.13, DriveMap V0.11 BETA, DriveDoppel V0.91 BETA.
Las imágenes virtuales de Runtime admiten dos esquemas RAID-6 distintos. El primero es un esquema basado puramente en XOR, en el que las unidades se someten a múltiples operaciones XOR para que la matriz sea resistente al fallo de hasta dos unidades. Veremos un ejemplo real de un RAID-6 compuesto por 4 unidades en un controlador Adaptec AIC-9405W.
El segundo esquema es una implementación Reed-Solomon que utiliza una unidad para la paridad XOR de tipo RAID-5 y una segunda para la paridad Reed-Solomon. Veremos un ejemplo de un RAID-6 de 6 unidades en un controlador RocketRaid 4520SGL .
Para ambos esquemas RAID-6, le mostraremos cómo crear el archivo VIM para reconstruir la matriz tras el fallo de 0, 1 o 2 unidades.
Este esquema utiliza únicamente XOR y, por lo tanto, es fácil de analizar. El controlador RAID selecciona los bloques de datos y paridad de modo que queden dispersos por todas las unidades, tanto horizontal como verticalmente, lo que garantiza la recuperación en caso de fallo de dos unidades.
| Múltiple basado en XOR | ||||||||||||
| Ejemplo: RAID-6, 4 unidades, tamaño de bloque 128 en Adaptec AIC-9405W | ||||||||||||
| Unidad local sector*)\ |
Unidad 1 | Unidad 2 | Unidad 3 | Unidad 4 | Ciclo | Banda | ||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0-127 | B1 **) | B2 | B3 | B4 | 0 | 0 | ||||||
| 128-255 | P1***) | P2 | P3 | P4 | 1 | |||||||
| 256-383 | B5 | B6 | B7 | B8 | 1 | 0 | ||||||
| 384-511 | P5 | P6 | P7 | P8 | 1 | |||||||
| : | : | : | : | : | : | : | ||||||
|
||||||||||||
Las bandas alternan entre bloques de datos puros y bloques de paridad:
B3 xor B4 => P1
B1 xor B4 => P2
B1 xor B2 => P3
B2 xor B3 => P4
Estas paridades garantizan que incluso la pérdida de dos unidades pueda mitigarse. Si, por ejemplo, fallan la unidad 1 y la unidad 2, puede reconstruir B2 a partir de B3 xor P4 y, a continuación, B1 a partir de B2 xor P3.
VIM para extraer los datos utilizando todas las unidades:
<virtualimage>
<loop>
<drive>...ada_1.img: </drive>
<drive>...ada_2.img: </drive>
<drive>...ada_3.img: </drive>
<drive>...ada_4.img: </drive>
<cycle blocksize="128">
<stripe>1,2,3,4</stripe>
<stripe></stripe>
</cycle>
</loop>
</virtualimage>
Si no falta ninguna unidad, podemos simplemente obtener los datos de los bloques de datos de cada banda.
La primera banda recupera 128 sectores de cada unidad en el orden de las unidades 1, 2, 3 y 4. La siguiente banda está vacía y solo contiene las paridades que no necesitamos. La banda vacía aumenta el contador de sectores de 128 a 256, por lo que la primera banda en la siguiente iteración del ciclo vuelve a devolver datos de las unidades 1, 2, 3 y 4.
VIM para extraer los datos tras el fallo de una unidad:
<virtualimage>
<loop>
<drive>...ada_1.img: </drive>
<drive>...ada_2.img: </drive>
<drive>...ada_3.img: </drive>
<drive>...ada_4.img: </drive>
<cycle blocksize="128">
<stripe>2x3(1),2,3,4</stripe>
<stripe></stripe>
</cycle>
</loop>
</virtualimage>
Suponiendo que falta la unidad 1, podemos recrearla sustituyendo la aparición de la unidad 1 por B2 xor P3.
Como P3 se encuentra en la siguiente banda, debemos adelantarnos en nuestra expresión de bandas. Esto se realiza con 3(1), que indica «unidad 3 una banda por delante». Nuestra expresión de banda 2x3(1),2,3,4 recupera 128 sectores de la unidad 2, los combina con el contenido de la unidad 3 en 128 sectores más adelante y, a continuación, recopila las unidades restantes 2, 3 y 4. La siguiente banda está vacía de nuevo, ya que ya hemos recopilado lo que necesitamos con la vista previa. La banda vacía aumenta el contador de sectores de 128 a 256, por lo que la primera banda en la siguiente iteración del ciclo vuelve a devolver datos de 2x3(1),2,3,4.
VIM para extraer los datos tras el fallo de dos unidades:
<virtualimage>
<loop>
<drive>...ada_1.img: </drive>
<drive>...ada_2.img: </drive>
<drive>...ada_3.img: </drive>
<drive>...ada_4.img: </drive>
<cycle blocksize="128">
<stripe>3x4(1)x3(1),3x4(1),3,4
</stripe>
<stripe></stripe>
</cycle>
</loop>
</virtualimage>
Suponiendo que faltan las unidades 1 y 2, podemos recrearlas sustituyendo las apariciones de la unidad 2 por B3 xor P4, y las de la unidad 1 por B2 xor P3.
Como P3 y P4 se encuentran en la siguiente banda, debemos volver a adelantarnos en nuestra expresión de banda. Esto se consigue con 3(1) y 4(1), que indican «unidad 3 una banda por delante» y «unidad 4 una banda por delante», respectivamente. Nuestra expresión de banda 3x4(1)x3(1),3x4(1),3,4 recupera la unidad 2 utilizando 3x4(1) y la unidad 1 utilizando la unidad 2 recién recuperada utilizando XOR con 3x4(1).
La siguiente banda está vacía de nuevo, ya que ya hemos recopilado lo que necesitamos con la vista previa. La banda vacía aumenta el contador de sectores de 128 a 256, por lo que la primera banda en la siguiente iteración del ciclo vuelve a devolver datos de 3x4(1)x3(1),3x4(1),3,4.
Este esquema emplea dos algoritmos de paridad distintos para los bloques de datos, XOR y corrección de errores Reed-Solomon, lo que permite una redundancia de 2 unidades. RS es elegante porque permite que ambos bloques de paridad, P y R, roten por las unidades sin almacenar los bloques de paridad en bandas especiales. Por otro lado, RS es más complicado de calcular que XOR. RS no es conmutativo, mientras que XOR sí lo es.
| Basado en Reed-Solomon y XOR | ||||||||||||
| Ejemplo: RAID-6, 6 unidades, tamaño de bloque 128 en un controlador RocketRaid 4520SGL | ||||||||||||
| Unidad local sector*)\ |
Unidad 1 | Unidad 2 | Unidad 3 | Unidad 4 | Unidad 5 | Unidad 6 | Ciclo | Banda | ||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0-127 | B1 **) | B2 | B3 | B4 | P | R | 0 | 0 | ||||
| 128-255 | B5 | B6 | B7 | P | R | B8 | 1 | |||||
| 256-383 | B9 | B10 | P | R | B11 | B12 | 2 | |||||
| 384-511 | B13 | P | R | B14 | B15 | B16 | 3 | |||||
| 512-639 | P | R | B17 | B18 | B19 | B20 | 4 | |||||
| 640-767 | R | B21 | B22 | B23 | B24 | P | 5 | |||||
| 768-895 | B25 | B26 | B27 | B28 | P | R | 1 | 0 | ||||
| 896-1023 | B29 | B30 | B31 | P | R | B32 | 1 | |||||
| : | : | : | : | : | : | : | : | : | ||||
|
||||||||||||
Todas las relaciones entre los datos y los bloques de paridad se expresan dentro de la misma banda. No hay vista previa como en el esquema anterior. Estas son las relaciones:
Banda 0:
B1 xor B2 xor B3 xor B4 => P B1 rs B2 rs B3 rs B4 => R
Banda 1: B5 xor B6 xor B7 xor B8 => P B5 rs B6 rs B7 rs B8 => R
Banda 2: B9 xor B10 xor B11 xor B12 => P B9 rs B10 rs B11 rs B12 => R
etc.
Como puede ver, los fallos de una sola unidad se pueden resolver fácilmente con P. Si necesita recuperar datos de dos unidades, también necesitará R. Más adelante mostraremos cómo incorporar ambas operaciones, XOR y RS, en un archivo VIM.
VIM para extraer los datos utilizando todas las unidades:
<virtualimage>
<loop>
<drive>...high_1.img: </drive>
<drive>...high_2.img: </drive>
<drive>...high_3.img: </drive>
<drive>...high_4.img: </drive>
<drive>...high_5.img: </drive>
<drive>...high_6.img: </drive>
<cycle blocksize="128">
<stripe>1,2,3,4</stripe>
<stripe>1,2,3,6</stripe>
<stripe>1,2,5,6</stripe>
<stripe>1,4,5,6</stripe>
<stripe>3,4,5,6</stripe>
<stripe>2,3,4,5</stripe>
</cycle>
</loop>
</virtualimage>
Si no falta ninguna unidad, podemos simplemente obtener los datos de los bloques de datos de cada banda. Consulte la tabla de rotación Reed-Solomon para determinar las unidades de datos para cada banda: son 1, 2, 3, 4 para la banda 0, 1, 2, 3, 6 para la banda 1, 1, 2, 5, 6 para la banda 2, 1, 4, 5, 6 para la banda 3, 3, 4, 5, 6 para la banda 4 y 2, 3, 4, 5 para la banda 5.
Estos 6 vectores son exactamente lo que se ve en este archivo VIM.
VIM para extraer los datos tras el fallo de una unidad utilizando paridad:
<virtualimage>
<loop>
<drive>...high_1.img: </drive>
<drive>...high_2.img: </drive>
<drive>...high_3.img: </drive>
<drive>...high_4.img: </drive>
<drive>...high_5.img: </drive>
<drive>...high_6.img: </drive>
<cycle blocksize="128">
<stripe>2x3x4x5,2,3,4</stripe>
<stripe>2x3x4x6,2,3,6</stripe>
<stripe>2x3x5x6,2,5,6</stripe>
<stripe>2x4x5x6,4,5,6</stripe>
<stripe>3,4,5,6</stripe>
<stripe>2,3,4,5</stripe>
</cycle>
</loop>
</virtualimage>
Si falta una unidad, podemos recrearla simplemente aplicandola paridad P. En la práctica, realizamos una operación XOR con P y las unidades de datos que han sobrevivido.
Suponiendo que falta la unidad 1, escribamos los 6 vectores para nuestras bandas. Observe la tabla de rotación, banda 0: desde la unidad 1 hasta la unidad 6, las unidades de datos y paridad están ordenadas DDDDPR. Podemos sustituir la unidad 1 que falta por 2x3x4x5. Las unidades 2, 3 y 4 son las unidades de datos restantes y P es la unidad de paridad XOR de esta banda.
Banda 0:
D,D,D,D,P,R -> 1,2,3,4,5,6 --(reemplazar 1 por 2x3x4x5)-> 2x3x4x5,2,3,4
Banda 1:
D,D,D,P,R,D -> 1,2,3,4,5,6 --(reemplazar 1 por 2x3x4x6)-> 2x3x4x6,2,3,6
Banda 2:
D,D,P,R,D,D -> 1,2,3,4,5,6 --(reemplazar 1 por 2x3x5x6)-> 2x3x5x6,2,5,6
Banda 3:
D,P,R,D,D,D -> 1,2,3,4,5,6 --(reemplazar 1 por 2x4x5x6)-> 2x4x5x6,4,5,6
Banda 4:
P,R,D,D,D,D -> 1,2,3,4,5,6 --(sin sustitución)-> 3,4,5,6
Banda 5:
R,D,D,D,D,P -> 1,2,3,4,5,6 --(sin sustitución)-> 2,3,4,5
Los 6 vectores de la derecha son nuestras descripciones de bandas en el archivo VIM.
VIM para extraer los datos tras el fallo de una unidad utilizando Reed-Solomon:
<virtualimage>
<loop>
<drive>...high_1.img: </drive>
<drive>...high_2.img: </drive>
<drive>...high_3.img: </drive>
<drive>...high_4.img: </drive>
<drive>...high_5.img: </drive>
<drive>...high_6.img: </drive>
<cycle blocksize="128">
<stripe>?r2r3r4r5r6,2,3,4</stripe>
<stripe>?r2r3r6r4r5,2,3,6</stripe>
<stripe>?r2r5r6r3r4,2,5,6</stripe>
<stripe>?r4r5r6r2r3,4,5,6</stripe>
<stripe>3,4,5,6</stripe>
<stripe>2,3,4,5</stripe>
</cycle>
</loop>
</virtualimage>
También podemos recuperar datos de un fallo de una sola unidad utilizando el algoritmo Reed-Solomon RS. Definimos RS como una función en todas las unidades, disponibles o no, en el orden correcto:
RS(D,D,D,D,P,R). Para su uso en el archivo VIM, lo escribimos como DrDrDrDrPrR. Consulte la tabla de rotación para sustituir los parámetros por el número de unidad correcto:
Banda 0: RS(1,2,3,4,5,6) -> 1r2r3r4r5r6
Banda 1: RS(1,2,3,6,4,5) -> 1r2r3r6r4r5
Banda 2: RS(1,2,5,6,3,4) -> 1r2r5r6r3r4
Banda 3: RS(1,4,5,6,2,3) -> 1r4r5r6r2r3
Banda 4: RS(3,4,5,6,1,2) -> 3r4r5r6r1r2
Banda 5: RS(2,3,4,5,6,1) -> 2r3r4r5r6r1
Suponiendo que falta la unidad 1, sustituimos el descriptor de unidad más a la izquierda por el descriptor RS para las primeras 4 bandas. Las dos últimas bandas, de nuevo, no requieren que reconstruyamos nada. Antes de insertar el descriptor RS, sustituya la unidad que falta por un ?. Esto indica qué salida necesitamos. Para la banda 0, 1r2r3r4r5r6 se convierte en ?r2r3r4r5r6.
VIM para extraer los datos tras el fallo de dos unidades:
<virtualimage>
<loop>
<drive>...high_1.img: </drive>
<drive>...high_2.img: </drive>
<drive>...high_3.img: </drive>
<drive>...high_4.img: </drive>
<drive>...high_5.img: </drive>
<drive>...high_6.img: </drive>
<cycle blocksize="128">
<stripe>!r?r3r4r5r6,?r!r3r4r5r6,3,4 </stripe>
<stripe>!r?r3r6r4r5,?r!r3r6r4r5,3,6 </stripe>
<stripe>!r?r5r6r3r4,?r!r5r6r3r4,5,6 </stripe>
<stripe>!r4r5r6r?r3,4,5,6 </stripe>
<stripe>3,4,5,6 </stripe>
<stripe>3x4x5x6,3,4,5 </stripe>
</cycle>
</loop>
</virtualimage>
En este párrafo, lo pondremos todo junto: XOR y RS para recuperar después de un fallo de dos unidades.
Suponiendo que faltan las unidades 1 y 2, tendremos que sustituir los descriptores de unidad 1 y 2 en la banda 0. Según el párrafo anterior, la función RS para la banda 0 es 1r2r3r4r5r6. Usar ? y ! para las unidades perdidas, ! siendo la unidad que desea calcular. Para la banda 1, la función RS es 1r2r3r6r4r5 y los descriptores para las unidades 1 y 2 son
Banda 0: 1r2r3r4r5r6 => 1,2,3,4 => !r?r3r4r5r6,?r!r3r4r5r6,3,4
Banda 1: 1r2r3r6r4r5 => 1,2,3,6 => !r?r3r6r4r5,?r!r3r6r4r5,3,6
Banda 2: 1r2r5r6r3r4 => 1,2,5,6 => !r?r5r6r3r4,?r!r5r6r3r4,5,6
Banda 3: 1r4r5r6r2r3 => 1,4,5,6 => !r4r5r6r?r3,4,5,6
Banda 4: 3r4r5r6r1r2 => 3,4,5,6 => 3,4,5,6
Banda 5: 2r3r4r5r6r1 => 2,3,4,5 => 3x4x5x6,3,4,5 (or !r3r4r5r6r?,3,4,5)