RAID5重组C代码

/****************************************************************************\
*                                                                            *
*  raidrec v0.6 - Manually try to put a RAID5 array back together.           *
*                                                                            *
*  I wrote this program when, after a few disk failures, md refused to put   *
*  my damaged RAID array back together itself, or tried to resync it incor-  *
*  rectly, further damaging my partitions.                                   *
*                                                                            *
*  Instead of figuring out how to do this, I decided to just write a small   *
*  program that does all the required XOR-ing.                               *
*                                                                            *
*  Note that I wrote this tool to scratch *my* specific itch, it's possible  *
*  that your RAID5 array was built differently. Mine had a stripe size of    *
*  64K. If yours is different, try changing the #define down here. Also, my  *
*  array is left-symmetric so if yours isn't, this tool is going to expect   *
*  the checksum at the wrong place. I haven't made this configurable. But    *
*  since AFAIK left-symmetric is the default setup, you may be lucky. It     *
*  may also work with some hardware RAID disks, depending on the setup.      *
*                                                                            *
*  Usage is very simple: Run the tool, pass it the partitions/images you're  *
*  trying to recover, and the reconstructed image will be written to std-    *
*  out. If one of the images is missing or corrupted, pass an empty string   *
*  instead. Its data will then be reconstructed.                             *
*                                                                            *
*  Example:                                                                  *
*  root@txt:/mnt/toscadisks# /root/raidrec sda2 '' sdc2 > md2                *
*                                                                            *
*  If you're impatient and want some kind of progress indicator, you can     *
*  pipe stuff through pv: http://www.ivarch.com/programs/pv.shtml            *
*                                                                            *
*  Use this tool at your own risk. I can't guarantee that it will work, but  *
*  definitely did for me. Obviously, don't use it on your partitions direc-  *
*  tly, but on block-by-block copies of them. If you have any questions,     *
*  feel free to e-mail me, but I can't guarantee a quick response, sorry.    *
*  If the program actually helped you, I'd also love to hear about it!       *
*                                                                            *
*  But please, no questions like "how do I compile this" or anything like    *
*  that. If you have to ask that, you'll be better off sending your disks    *
*  to a professional recovery company as soon as possible. Doing something   *
*  wrong here could only get you in more trouble.                            *
*                                                                            *
*  Good luck!                                                                *
*                                                                            *
*  Copyright 2009 Wilmer van der Gaast. <wilmer@gaast.net>                   *
*  Licensed under the GPLv2.                                                 *
*                                                                            *
\****************************************************************************/

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAXCOLS 5
#define STRIPESIZE 0x10000

char *getblocks( int ncols, char **istr, int xor_col );

int main( int argc, char *argv[] )
{
        int ifd[MAXCOLS];
        char **istr;
        int i, n, ncols;
        
        ncols = argc - 1;
        if( ncols > MAXCOLS || ncols < 3 )
        {
                fprintf( stderr, "Invalid number of columns.\n" );
                return 1;
        }
        
        n = 0;
        istr = malloc( sizeof( char* ) * ncols );
        for( i = 0; i < ncols; i ++ )
        {
                if( strcmp( argv[i+1], "" ) != 0 )
                {
                        ifd[i] = open( argv[i+1], O_RDONLY );
                        if( ifd[i] == -1 )
                        {
                                perror( "open" );
                                return 1;
                        }
                        istr[i] = malloc( STRIPESIZE );
                }
                else
                {
                        if( ( n ++ ) > 0 )
                        {
                                fprintf( stderr, "More than one missing image.\n" );
                                return 1;
                        }
                        
                        ifd[i] = -1;
                        istr[i] = NULL;
                }
        }
        
        while( 1 )
        {
                static int xor_col = 0;
                
                xor_col = ( xor_col + ncols - 1 ) % ncols;
                
                for( i = 0; i < ncols; i ++ )
                {
                        if( istr[i] == NULL )
                                continue;
                        
                        if( ( n = read( ifd[i], istr[i], STRIPESIZE ) ) != STRIPESIZE )
                        {
                                if( n == 0 )
                                {
                                        return 0;
                                }
                                else
                                {
                                        perror( "read" );
                                        return 1;
                                }
                        }
                }
                write( 1, getblocks( ncols, istr, xor_col ), ( ncols - 1 ) * STRIPESIZE );
        }
}

char *getblocks( int ncols, char **istr, int xor_col )
{
        static char ret[(MAXCOLS-1)*STRIPESIZE], *s;
        int cur_col;
        int i;
        
        cur_col = ( xor_col + 1 ) % ncols;
        s = ret;
        
        for( i = 0; i < ( ncols - 1 ); i ++ )
        {
                if( istr[cur_col] )
                {
                        memcpy( s, istr[cur_col], STRIPESIZE );
                }
                else
                {
                        int j;
                        
                        memset( s, 0, STRIPESIZE );
                        
                        for( j = 0; j < ( ncols - 1 ); j ++ )
                        {
                                long *ip, *op;
                                
                                cur_col = ( cur_col + 1 ) % ncols;
                                ip = (long*) istr[cur_col];
                                op = (long*) s;
                                
                                while( op < (long*) ( s + STRIPESIZE ) )
                                {
                                        *op ^= *ip;
                                        ip ++;
                                        op ++;
                                }
                        }
                        cur_col = ( cur_col + 1 ) % ncols;
                }
                s += STRIPESIZE;
                cur_col = ( cur_col + 1 ) % ncols;
        }
        
        return ret;
}