Abstract:
The memory of the storage device is divided into information areas of identical size selected from different parts of the storage device, and control zones are selected from different parts of the device. Each group of data is a set of code words written to a corresponding information zone. Three reference control sums S 0 , S 1 , S 2 , each according to a corresponding preset formula, are established by a computation unit. The reference control sums are written as a code word with the same number to a corresponding control zone. If a part of the storage device fails and data becomes corrupted, the current control sums are calculated with the aid of the computation unit. The values of the stored reference control sums and the current control sums are used for recovering lost data. The number of equations depends on the number of failed or faulty zones in the storage device.

Description:
RELATED APPLICATIONS 
       [0001]    This application is a Continuation application of International Application PCT/RU2013/000579, filed on Jul. 9, 2013, which in turn claims priority to Russian Patent Applications No. RU2012140679, filed Sep. 12, 2012, both of which are incorporated herein by reference in their entirety. 
     
    
     FIELD OF THE INVENTION 
       [0002]    The present invention relates to the systems for detecting and correcting data errors on data carriers, in particular in the case of failure or damage of a part of a storage device or corruption of data on the storage device. 
       BACKGROUND OF THE INVENTION 
       [0003]    A key technology to ensure reliability of storing data in the storage device is the ability to recover the data in case of failure of one or more zones of the storage device. At present, most storage devices are used to store large amounts of information, represented as disks arrays, one may consider the possibility of data recovery in case of failure of one or more hard disks. For this, a variety of erasure coding methods and so-called redundant disks arrays RAID (redundant array of independent disks) are used. The recovery is performed by calculating and storing the redundant information (checksums), which allows the recovery of the lost data, but requires additional disk space. (See, for example, Anvin, NR (last update 20 Dec. 2011). Obtained in Aug. 25, 2012 at the address http://ftp.kernel.org/pub/linux/kernel/people/ripa/raid6.pdf). 
         [0004]    The methods and systems used to recover records in storage devices using RAID arrays are described in many patent documents, as an example, U.S. Pat. No. 7,392,458 (publ. 24 Jun. 2008), U.S. Pat. No. 7,437,658 (publ. 14 Oct. 2008), U.S. Pat. No. 7,600,176 (publ. 6 Oct. 2009); in applications for U.S. Patent No. 2009/0132851 (publ. 21 May 2009), 20100229033, (publ. 9 Sep. 2010), 20110145677 (publ. 16 Jun. 2011), 20110167294 (publ. 7 Jul. 2011), 20110264949 (publ. 27 Oct. 2011). 
         [0005]    The closest solution to the present is according to RF patent No. 2448361, published on 24 Apr. 2012. This solution suggests a method to restore records in a storage device, wherein when data is written into information zones of the storage device, two reference checksums, calculated by the predetermined formula, are entered in its respective control zones, and in the process of using the storage device, the current checksums are repeatedly calculated by the computing unit by the same formula for each set of code words with the same numbers in all information areas and the obtained current checksum is compared with the corresponding reference checksum to define the syndrome of errors and to replace the identified write errors with the correct values. The technical result of the invention under the patent RU 2448361 is the increased speed of calculations in the recovery disk. 
         [0006]    However, the known methods may not ensure sufficient reliability for large arrays of stored information due to the parameters of reliability of modern storage devices. Thus, the current level of technology enables to ensure the sufficient reliability for arrays up to 24 TB, combined with RAID-6 technology. When using a large number of disks, the real risk of failure of two or more disks may appear. In practice, this risk is overcome by splitting up large arrays into the small, which implies additional expenses to use large amounts of memory to store the checksums. Thus, there is a need for new methods of records recovery to store large amounts of data in a storage device. 
       SUMMARY OF THE INVENTION 
       [0007]    The present invention provides for the calculation and storage of three checksums in a memory. This allows restoration of a greater number of simultaneously failed parts of a storage device, which increases its performance and reliability, while reducing the amount of memory needed to store a checksum in large arrays. Moreover, the proposed method allows not only to recover data in case of failure or damage of the storage device, but also provides data recovery in case of data corruption of the storage device. 
         [0008]    To solve the problem and to achieve the said technical result, the present invention provides a method to recover records in the storage device in case of failure or damage of a part of the storage device or data corruption of the storage device. 
         [0009]    To implement this method, the said memory of the storage device is divided into information and control zones of equal size, selected from different parts of the storage device. 
         [0010]    Each group of data to be saved is written in the form of a set of code words into a corresponding information zone. Each time the saved record is defined in a storage device by using the corresponding computing unit with three reference checksums S 0 , S 1 , S 2 , each corresponds to a predetermined formula: 
         [0000]    
       
         
           
             
               S 
               0 
             
             = 
             
               
                 
                   ∑ 
                   
                     i 
                     = 
                     0 
                   
                   
                     n 
                     - 
                     1 
                   
                 
                  
                 
                     
                 
                  
                 
                   D 
                   i 
                 
               
               = 
               
                 
                   D 
                   0 
                 
                 + 
                 
                   D 
                   1 
                 
                 + 
                 … 
                 + 
                 
                   D 
                   
                     n 
                     - 
                     1 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     S 
                     1 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         0 
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         D 
                         i 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           i 
                           - 
                           1 
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         D 
                         0 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     + 
                     
                       
                         D 
                         1 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           2 
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         n 
                         - 
                         1 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     ( 
                     
                       
                         
                           ( 
                           
                             
                               
                                 ( 
                                 
                                   
                                     
                                       D 
                                       0 
                                     
                                      
                                     a 
                                   
                                   + 
                                   
                                     D 
                                     1 
                                   
                                 
                                 ) 
                               
                                
                               a 
                             
                             + 
                             
                               D 
                               2 
                             
                           
                           ) 
                         
                          
                         a 
                       
                       + 
                       … 
                       + 
                       
                         D 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     ) 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     S 
                     2 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         0 
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         D 
                         i 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               i 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         
                           D 
                           0 
                         
                          
                         
                           a 
                           
                             2 
                              
                             
                               ( 
                               
                                 n 
                                 - 
                                 1 
                               
                               ) 
                             
                           
                         
                       
                       + 
                       
                         
                           D 
                           1 
                         
                          
                         
                           a 
                           
                             2 
                              
                             
                               ( 
                               
                                 n 
                                 - 
                                 2 
                               
                               ) 
                             
                           
                         
                       
                       + 
                       … 
                       + 
                       
                         D 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     = 
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     ( 
                     
                       
                         
                           ( 
                           
                             
                               
                                 ( 
                                 
                                   
                                     
                                       D 
                                       0 
                                     
                                      
                                     
                                       a 
                                       2 
                                     
                                   
                                   + 
                                   
                                     D 
                                     1 
                                   
                                 
                                 ) 
                               
                                
                               
                                 a 
                                 2 
                               
                             
                             + 
                             
                               D 
                               2 
                             
                           
                           ) 
                         
                          
                         
                           a 
                           2 
                         
                       
                       + 
                       … 
                       + 
                       
                         D 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     ) 
                   
                 
               
             
           
         
       
     
         [0011]    Where D i −i-information area in which the code words are recorded 
         [0012]    d i,1 , d i,2 , . . . , d i,s-1 ; i=0, . . . , n−1, the code words are elements of the Galois field; 
         [0013]    n is the number of information zones; 
         [0014]    s is the number of code words in one information zone; 
         [0015]    a is a primitive element of the Galois field. 
         [0016]    Next, each found reference checksum is written in the form of code words with the same number in the corresponding control zone, each of three checksums is stored in a separate zone of the storage device. In case of the failure or damage of a part of the storage device, wherein the corrupted data is detected, the current checksums are calculated with the aid of the computing unit by formulas for each set of code words with the same numbers in all of the information zones. 
         [0017]    The values of the stored reference checksums and the current checksums are used to restore the lost data, wherein the lost data is recovered with the reference and current checksums by solving the systems of equations obtained from the formulas of checksums calculation. The number of equations in the system depends on the number of failed or damaged zones of the storage device. 
         [0018]    This method allows to circumvent the technical limitations of storage element reliability and to create larger arrays of records in the storage device. This method restores data when up to three simultaneous failures arise. Failures can also occur in the part of the storage device that stores the checksums. Furthermore, this method allows to recover both read and write errors, which are not registered by the hardware. These results can be achieved by all features of this method, including the formation of three checksums stored in different parts of the storage device. It is important that the control checksums are calculated using the three formulas presented above and that the data is restored by using the reference and the current checksums and solving the systems of equations obtained from the formulas of checksums calculating. 
         [0019]    The records recovery system of the storage device in case of failure or damage of a part of the storage device or data corruption is based on the method, which contains:
       a memory device, which includes n equal size zones of information selected from different parts of the storage device and three control zones, selected from different parts of the storage device;   a computing unit.       
 
         [0022]    Each n information zone of the storage device is performed with the ability to write the group of data as a set of code words in itself; each of the said three control zones of the storage device is performed with the ability to write the corresponding checksum in itself; 
         [0023]    the said computing unit is configured to: 
         [0024]    define the reference checksums by using a predetermined formula, for each set of code words, where i=0, . . . , n−1 in all the said n information zones with every record of the data to be stored in the said storage device. 
         [0025]    The following formulas are used to calculate the S 0 , S 1 , S 2  checksums: 
         [0000]    
       
         
           
             
               S 
               0 
             
             = 
             
               
                 
                   ∑ 
                   
                     i 
                     = 
                     0 
                   
                   
                     n 
                     - 
                     1 
                   
                 
                  
                 
                     
                 
                  
                 
                   D 
                   i 
                 
               
               = 
               
                 
                   D 
                   0 
                 
                 + 
                 
                   D 
                   1 
                 
                 + 
                 … 
                 + 
                 
                   D 
                   
                     n 
                     - 
                     1 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     S 
                     1 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         0 
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         D 
                         i 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           i 
                           - 
                           1 
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         D 
                         0 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     + 
                     
                       
                         D 
                         1 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           2 
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         n 
                         - 
                         1 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     ( 
                     
                       
                         
                           ( 
                           
                             
                               
                                 ( 
                                 
                                   
                                     
                                       D 
                                       0 
                                     
                                      
                                     a 
                                   
                                   + 
                                   
                                     D 
                                     1 
                                   
                                 
                                 ) 
                               
                                
                               a 
                             
                             + 
                             
                               D 
                               2 
                             
                           
                           ) 
                         
                          
                         a 
                       
                       + 
                       … 
                       + 
                       
                         D 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     ) 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     S 
                     2 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         0 
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         D 
                         i 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               i 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         
                           D 
                           0 
                         
                          
                         
                           a 
                           
                             2 
                              
                             
                               ( 
                               
                                 n 
                                 - 
                                 1 
                               
                               ) 
                             
                           
                         
                       
                       + 
                       
                         
                           D 
                           1 
                         
                          
                         
                           a 
                           
                             2 
                              
                             
                               ( 
                               
                                 n 
                                 - 
                                 2 
                               
                               ) 
                             
                           
                         
                       
                       + 
                       … 
                       + 
                       
                         D 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     = 
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     ( 
                     
                       
                         
                           ( 
                           
                             
                               
                                 ( 
                                 
                                   
                                     
                                       D 
                                       0 
                                     
                                      
                                     
                                       a 
                                       2 
                                     
                                   
                                   + 
                                   
                                     D 
                                     1 
                                   
                                 
                                 ) 
                               
                                
                               
                                 a 
                                 2 
                               
                             
                             + 
                             
                               D 
                               2 
                             
                           
                           ) 
                         
                          
                         
                           a 
                           2 
                         
                       
                       + 
                       … 
                       + 
                       
                         D 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     ) 
                   
                 
               
             
           
         
       
     
         [0026]    where D i  denotes the i-th information area in which the code words d i,1 , d i,2 , . . . , d i,s-1  are recorded; i=0, . . . , n−1, the code words are treated as the elements of the Galois field; 
         [0027]    n is the number of information areas; 
         [0028]    s is the number of code words in one information area; 
         [0029]    a is a primitive element of the Galois field. 
         [0030]    The computing unit is designed with the ability to define the current checksums by the said formulas for each set of code words with the same numbers in all information zones in case of failure or damage of a part of memory of the storage device, the values of the stored reference checksums are used to recover the lost data. The lost data can be recovered using the reference and the current checksums by solving a system of equations obtained by the formula for checksums calculating, the number of equations in the system depends on the number of failed or damaged zones of the storage device. 
         [0031]    As in the case of this method, the system creates larger storage arrays, to recover up to three simultaneously failed parts of the storage devices and to restore the corrupted data, which is not registered by the hardware. 
         [0032]    In the particular case of the realization of this method, the values of the stored reference checksums and the current checksums are additionally used to detect the corrupted data. It is necessary to determine the location of the corrupted data. However, to restore the lost data, the presence of the corrupted data is determined by comparing the reference and the current checksums and a location of the corrupted data is defined using the system of equations obtained by the formulas of checksums calculating. 
         [0033]    An application of the operations of this method, including the design of the system extends the scope of the invention to search for corrupted data in the array. 
         [0034]    Another feature of the method, as well as of the system of the present invention is that the computing unit is a part of the said storage device. In another embodiment, the computing unit is external according to the said storage device. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0035]    The following detailed description is illustrated with drawings. 
           [0036]      FIG. 1  illustrates splitting a disk into the blocks that comprise the stripe. 
           [0037]      FIG. 2  illustrates splitting the information zones and code zones into the areas to store the code words. 
       
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
       [0038]    The claimed method is implemented as follows. The storage device is characterized by the common amount of memory. To implement this method, the total amount of memory should be split into information zones of the same size, selected from different parts of the storage device, and control zones, selected from different parts of the storage device. 
         [0039]    When a hard disk array is used as a storage device, disks are split into blocks of equal length. The sequence of blocks with the same numbers is located on different disks forms a stripe ( FIG. 1 ). The information zones and the control zones are the blocks of one stripe stored on different disks. Splitting the information zones and the code zones into the areas to store the code words is illustrated in  FIG. 2 . 
         [0040]    The following detailed description is based on the illustrative example, which demonstrates that the storage device is an array built from the multiple hard drives. The present invention can be also applied to storage devices of different types, for example, to a flash-memory based storage devices. 
         [0041]    The data to be stored is divided into the blocks wherein length is equal to the length of the hard disk&#39;s block. This data is written into the blocks of one stripe on different disks. For these blocks of the stripe, the following formulas are used: 
         [0000]    
       
         
           
             
               S 
               0 
             
             = 
             
               
                 
                   ∑ 
                   
                     i 
                     = 
                     0 
                   
                   
                     n 
                     - 
                     1 
                   
                 
                  
                 
                     
                 
                  
                 
                   D 
                   i 
                 
               
               = 
               
                 
                   D 
                   0 
                 
                 + 
                 
                   D 
                   1 
                 
                 + 
                 … 
                 + 
                 
                   D 
                   
                     n 
                     - 
                     1 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     S 
                     1 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         0 
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         D 
                         i 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           i 
                           - 
                           1 
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         D 
                         0 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     + 
                     
                       
                         D 
                         1 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           2 
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         n 
                         - 
                         1 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     ( 
                     
                       
                         
                           ( 
                           
                             
                               
                                 ( 
                                 
                                   
                                     
                                       D 
                                       0 
                                     
                                      
                                     a 
                                   
                                   + 
                                   
                                     D 
                                     1 
                                   
                                 
                                 ) 
                               
                                
                               a 
                             
                             + 
                             
                               D 
                               2 
                             
                           
                           ) 
                         
                          
                         a 
                       
                       + 
                       … 
                       + 
                       
                         D 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     ) 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     S 
                     2 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         0 
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         D 
                         i 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               i 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         
                           D 
                           0 
                         
                          
                         
                           a 
                           
                             2 
                              
                             
                               ( 
                               
                                 n 
                                 - 
                                 1 
                               
                               ) 
                             
                           
                         
                       
                       + 
                       
                         
                           D 
                           1 
                         
                          
                         
                           a 
                           
                             2 
                              
                             
                               ( 
                               
                                 n 
                                 - 
                                 2 
                               
                               ) 
                             
                           
                         
                       
                       + 
                       … 
                       + 
                       
                         D 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     = 
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     ( 
                     
                       
                         
                           ( 
                           
                             
                               
                                 ( 
                                 
                                   
                                     
                                       D 
                                       0 
                                     
                                      
                                     
                                       a 
                                       2 
                                     
                                   
                                   + 
                                   
                                     D 
                                     1 
                                   
                                 
                                 ) 
                               
                                
                               
                                 a 
                                 2 
                               
                             
                             + 
                             
                               D 
                               2 
                             
                           
                           ) 
                         
                          
                         
                           a 
                           2 
                         
                       
                       + 
                       … 
                       + 
                       
                         D 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     ) 
                   
                 
               
             
           
         
       
     
         [0042]    where D i  denotes the i-th information area in which the code words d i,1 , d i,2 , . . . , d i,s-1  are recorded; i=0, . . . , n−1, the code words are treated as the elements of the Galois field; 
         [0043]    n is the number of information areas; 
         [0044]    s is the number of code words in one information area; 
         [0045]    a is a primitive element of the Galois field. 
         [0046]    The computing unit calculates the S 0 , S 1 , S 2  syndrome values. A multiplication of the D i  by a primitive element a of a field or its power is considered as multiplication of corresponding polynomials modulo an irreducible polynomial generating the field. An operation of addition is considered as the operation of bitwise summation modulo 2 (XOR). 
         [0047]    For the aim of computation optimization, in practical implementation, the checksum calculation is performed according to the Homer scheme: 
         [0000]    
       
      
       S 
       0 
       =D 
       0 
       +D 
       1 
       + . . . +D 
       n-1  
      
     
         [0000]        S   1 =((( D   0   a+D   1 ) a+D   2 ) a+ . . . +D   n-1 ) 
         [0000]        S   2 =((( D   0   a   2   +D   1 ) a   2   +D   2 ) a   2   + . . . +D   n-1 ) 
         [0048]    The calculated values for syndromes are recorded on the disks to the same stripe as the data blocks. 
         [0049]    If the damage or failure of a part of the storage device or data corruption occurs, the data recovery is performed by solving the system of equations, obtained from the formulas of checksums calculation. The choice for the coefficients of equations the certain powers a i  of the primitive element guarantees the solvability of the system of equations with respect to any three of the values D 0 , D 1 , . . . , D n-1 . 
         [0050]    Consider the situation when storage device or its part is damaged during operation process. For an array of hard disks, it means that corruption occurs in the blocks of the stripe stored on the disks. The lost data is then recovered by stripes. 
         [0051]    Consider first the case, when one block of the stripe is damaged, that means a single disk array is failed. If the failed block is located within the control area, then the computing unit, using the formulas for checksum calculation, recalculates the current value for the corresponding damaged checksum. The obtained value is written instead of the invalid. 
         [0052]    In case where the damaged block happens to be within the information zone and the place j of this block is detected with hardware, the true value for D is restored with the aid of recalculation of the current value for the first checksum with omitting the summand corresponding to the failed block: 
         [0000]    
       
         
           
             
               
                 S 
                 ~ 
               
               0 
             
             = 
             
               
                 
                   ∑ 
                   
                     
                       i 
                       = 
                       0 
                     
                     
                       i 
                       ≠ 
                       j 
                     
                   
                   
                     n 
                     - 
                     1 
                   
                 
                  
                 
                   D 
                   i 
                 
               
               = 
               
                 
                   D 
                   0 
                 
                 + 
                 
                   D 
                   1 
                 
                 + 
                 … 
                 + 
                 
                   D 
                   
                     j 
                     - 
                     1 
                   
                 
                 + 
                 
                   D 
                   
                     j 
                     + 
                     1 
                   
                 
                 + 
                 … 
                 + 
                 
                   D 
                   
                     n 
                     - 
                     1 
                   
                 
               
             
           
         
       
     
         [0053]    Using the value of the stored reference checksum S 0  and the value of the current checksum {tilde over (S)} 0 , the computing unit calculates the value of the failed information zone by the formula D j =S 0 +{tilde over (S)} 0 . The obtained value is then written instead of the invalid. 
         [0054]    In case of damage to one information zone, the data can also be restored with the aid of checksum S 1 . In comparison with the algorithm mentioned above, this method requires more computational resources, but necessity in its usage is justified in the situation where, in addition to the damage occurrence of the information block, the S 0  checksum block is also damaged in the stripe. Moreover, this recovery method can be applied in advanced reconstruction mode. The advanced reconstruction mode is a reading data mode, which speeds up the process of obtaining information, when the read speed of any drive falls. The system can restore the data from a slow disk instead of performing the reading operation. For example, if in the process of reading blocks from a disk, the checksum S 0 , S 2  and one information zone are remained as unread, it is possible, without waiting for the reading process completing, to restore the value of the information zone, and to recalculate the values S 0 , S 2  of checksums. The advanced reconstruction mode can speed up the reading process, if any drive has started to work slowly. 
         [0055]    For recovering the damaged block D j  with the aid of the checksum S 1 , its current value {tilde over (S)} 1  is recalculated by using the computing unit by the formula: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       S 
                       ~ 
                     
                     1 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         
                           i 
                           = 
                           0 
                         
                         
                           i 
                           ≠ 
                           j 
                         
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                       
                         D 
                         i 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           i 
                           - 
                           1 
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         D 
                         0 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     + 
                     
                       
                         D 
                         1 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           2 
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       
                         D 
                         
                           j 
                           - 
                           1 
                         
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           j 
                         
                       
                     
                     + 
                     
                       
                         D 
                         
                           j 
                           + 
                           1 
                         
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           j 
                           - 
                           2 
                         
                       
                        
                       
                           
                       
                        
                       … 
                     
                     + 
                     
                       D 
                       
                         n 
                         - 
                         1 
                       
                     
                   
                 
               
             
           
         
       
     
         [0056]    (thus, the value of the failed block is ignored in calculation of the checksum). 
         [0057]    Using the value of the stored reference checksum S 1  and the value of the current checksum {tilde over (S)} 1 , the computing unit calculates the value of the failed information zone according to the formula: 
         [0000]        D   j =( S   1   +{tilde over (S)}   1 ) a   −(n-j-1)    
         [0058]    Here a −1  means inversion of the element of the Galois field. 
         [0059]    The obtained value is written instead of the invalid. 
         [0060]    Calculating the inverse element of the field requires substantial computing resources. 
         [0061]    In practice, it is better to choose the values of the inverse elements from the pre-calculated tables. 
         [0062]    In case of damage to one information zone, data can be restored at the expense checksum S 2 . This method requires more computational resources, but it is necessary, if in addition to the damage of the information zone, the S 0  checksum block in the stripe is also damaged. Moreover, this recovery method can be applied in advanced reconstruction mode. If a block D j  of the information zone is damaged, where j is the number of the damaged unit in stripe, it is known to us, because the failure is logged by the hardware. Then, the computing unit calculates the current checksum {tilde over (S)} 2 . Then, the current checksum {tilde over (S)} 2  is calculated by using the computing unit. Wherein the value of the failed block stripe is passed when the current checksum is calculated. 
         [0063]    The computing unit according to the formula calculates the value of the current checksum: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       S 
                       ~ 
                     
                     2 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         
                           i 
                           = 
                           0 
                         
                         
                           i 
                           ≠ 
                           j 
                         
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                       
                         D 
                         i 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               i 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         D 
                         0 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       
                         D 
                         
                           j 
                           - 
                           1 
                         
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               j 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     
                       
                         D 
                         
                           j 
                           + 
                           1 
                         
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               j 
                               - 
                               2 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         n 
                         - 
                         1 
                       
                     
                   
                 
               
             
           
         
       
     
         [0064]    Using the value of the stored reference checksum S 2  and the value of the current checksum {tilde over (S)} 2 , the computing unit calculates the value of the invalid information zone according to the formula D j =(S 2 +{tilde over (S)} 2 )a −2(n-j-1)    
         [0065]    The obtained value is written instead of the invalid. 
         [0066]    Consider now the case where two blocks are damaged in the stripe, which corresponds to the failure of two disks in the array. In addition, this recovery method is applied, if unrecoverable reading error occurs (UER) during the reconstruction of one of the failed disk, and, therefore, two blocks are damaged. If the blocks of the control zones are damaged, then the computing unit calculates the current checksum that corresponds to the damaged control zones using the checksum calculation formulas. The obtained checksum values are recorded instead of the damaged values. If one of the damaged blocks belongs to the information zone and the other one belongs to the control zone, the data is restored according to the scheme described above for one of the failed blocks, and the value of the damaged control zone is calculated according to the formula of checksums calculating. 
         [0067]    Let D j  and D k  blocks of the information zone be damaged, with their numbers j and k be discovered by the hardware. Then, the computing unit recalculates the current checksums {tilde over (S)} 0 , {tilde over (S)} 1  with omitting the summands corresponding to the failed blocks: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       S 
                       ~ 
                     
                     0 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         
                           i 
                           = 
                           0 
                         
                         
                           
                             i 
                             ≠ 
                             j 
                           
                           , 
                           
                             i 
                             ≠ 
                             k 
                           
                         
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                       D 
                       i 
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       D 
                       0 
                     
                     + 
                     
                       D 
                       1 
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         j 
                         - 
                         1 
                       
                     
                     + 
                     
                       D 
                       
                         j 
                         + 
                         1 
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         k 
                         - 
                         1 
                       
                     
                     + 
                     
                       D 
                       
                         k 
                         + 
                         1 
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         n 
                         - 
                         1 
                       
                     
                   
                 
               
             
           
         
       
       
         
           
             
                 
             
              
             
               
                 
                   
                     
                       
                         S 
                         ~ 
                       
                       1 
                     
                     = 
                       
                      
                     
                       
                         ∑ 
                         
                           
                             i 
                             = 
                             0 
                           
                           
                             
                               i 
                               ≠ 
                               j 
                             
                             , 
                             
                               i 
                               ≠ 
                               k 
                             
                           
                         
                         
                           n 
                           - 
                           1 
                         
                       
                        
                       
                         
                           D 
                           i 
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             i 
                             - 
                             1 
                           
                         
                       
                     
                   
                 
               
               
                 
                   
                     = 
                       
                      
                     
                       
                         
                           D 
                           0 
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             1 
                           
                         
                       
                       + 
                       … 
                       + 
                       
                         
                           D 
                           
                             j 
                             - 
                             1 
                           
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             j 
                           
                         
                       
                       + 
                       
                         
                           D 
                           
                             j 
                             + 
                             1 
                           
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             j 
                             - 
                             2 
                           
                         
                       
                       + 
                       … 
                       + 
                     
                   
                 
               
               
                 
                   
                       
                      
                     
                       
                         
                           D 
                           
                             k 
                             - 
                             1 
                           
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             k 
                           
                         
                       
                       + 
                       
                         
                           D 
                           
                             k 
                             + 
                             1 
                           
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             k 
                             - 
                             2 
                           
                         
                       
                       + 
                       … 
                       + 
                       
                         D 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                   
                 
               
             
           
         
       
     
         [0068]    Using the values of the stored reference checksums S 0 , S 1  and the current checksums {tilde over (S)} 0 , {tilde over (S)} 1 , the computing unit calculates the values of the invalid information zones according to the formulas: 
         [0000]        D   k =( S   1   +{tilde over (S)}   1 +( S   0   +{tilde over (S)}   0 ) a   n-j-1 )[ a   n-k-1   +a   n-j-1 ] −1    
         [0000]    
       
      
       D 
       j 
       =S 
       0 
       +{tilde over (S)} 
       0 
       +D 
       k  
      
     
         [0069]    The obtained values are recorded instead of the invalid. 
         [0070]    This recovery method can also be applied in the advanced reconstruction mode. 
         [0071]    In case of damage of two information zones, the data can also be restored with the aid of checksums S 0 , S 2 . In comparison with the previous approach, this method requires more computational resources. However, its necessity is caused by the situation where, in addition to the damage of the information zone, the checksum block S 1  in the stripe is also damaged. 
         [0072]    Moreover, this recovery method can be applied in the mode of advanced reconstruction. If the damaged blocks are denoted by D j  and D k , one should recalculate the checksums {tilde over (S)} 0 , {tilde over (S)} 2  by the formulas: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       S 
                       ~ 
                     
                     0 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         
                           i 
                           = 
                           0 
                         
                         
                           
                             i 
                             ≠ 
                             j 
                           
                           , 
                           
                             i 
                             ≠ 
                             k 
                           
                         
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                       D 
                       i 
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       D 
                       0 
                     
                     + 
                     
                       D 
                       1 
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         j 
                         - 
                         1 
                       
                     
                     + 
                     
                       D 
                       
                         j 
                         + 
                         1 
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         k 
                         - 
                         1 
                       
                     
                     + 
                     
                       D 
                       
                         k 
                         + 
                         1 
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         n 
                         - 
                         1 
                       
                     
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     
                       S 
                       ~ 
                     
                     2 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         
                           i 
                           = 
                           0 
                         
                         
                           
                             i 
                             ≠ 
                             j 
                           
                           , 
                           
                             i 
                             ≠ 
                             k 
                           
                         
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                       
                         D 
                         i 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               i 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         D 
                         0 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       
                         D 
                         
                           j 
                           - 
                           1 
                         
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               j 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     
                       
                         D 
                         
                           j 
                           + 
                           1 
                         
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               j 
                               - 
                               2 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       
                         D 
                         
                           k 
                           - 
                           1 
                         
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               k 
                             
                             ) 
                           
                         
                       
                     
                     + 
                   
                 
               
             
             
               
                 
                     
                    
                   
                     
                       
                         D 
                         
                           k 
                           + 
                           1 
                         
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               k 
                               - 
                               2 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         n 
                         - 
                         1 
                       
                     
                   
                 
               
             
           
         
       
     
         [0073]    Using the values of the stored reference checksums S 0 , S 2  and the values of the current checksums {tilde over (S)} 0 , {tilde over (S)} 2 , the computing unit calculates the values of the damaged information zones according to the formulas: 
         [0000]        D   k =( S   2   +{tilde over (S)}   2 +( S   0   +{tilde over (S)}   0 ) a   2(n-j-1) )[ a   2(n-k-1)   +a   2(n-j-1) ] −1    
         [0000]    
       
      
       D 
       j 
       =S 
       0 
       +{tilde over (S)} 
       0 
       +D 
       k  
      
     
         [0074]    The obtained values are recorded instead of the invalid. 
         [0075]    In case of damage of two information zones, the data can also be restored with the aid of checksums S 1 , S 2 . In comparison with the previous approach, this method requires more computational resources. However, its necessity is caused by the situation where, in addition to the damage of the information zone, the checksum block S 0  in the stripe is also damaged. Moreover, this recovery method can be applied in the mode of advanced reconstruction. If the damaged blocks are denoted by D j  and D k , one should recalculate the checksums {tilde over (S)} 1 , {tilde over (S)} 2  by the formulas: 
         [0000]    
       
         
           
             
                 
             
              
             
               
                 
                   
                     
                       
                         S 
                         ~ 
                       
                       1 
                     
                     = 
                       
                      
                     
                       
                         ∑ 
                         
                           
                             i 
                             = 
                             0 
                           
                           
                             
                               i 
                               ≠ 
                               j 
                             
                             , 
                             
                               i 
                               ≠ 
                               k 
                             
                           
                         
                         
                           n 
                           - 
                           1 
                         
                       
                        
                       
                         
                           D 
                           i 
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             i 
                             - 
                             1 
                           
                         
                       
                     
                   
                 
               
               
                 
                   
                     = 
                       
                      
                     
                       
                         
                           D 
                           0 
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             1 
                           
                         
                       
                       + 
                       … 
                       + 
                       
                         
                           D 
                           
                             j 
                             - 
                             1 
                           
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             j 
                           
                         
                       
                       + 
                       
                         
                           D 
                           
                             j 
                             + 
                             1 
                           
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             j 
                             - 
                             2 
                           
                         
                       
                       + 
                       … 
                       + 
                       
                         
                           D 
                           
                             k 
                             - 
                             1 
                           
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             k 
                           
                         
                       
                       + 
                     
                   
                 
               
               
                 
                   
                       
                      
                     
                       
                         
                           D 
                           
                             k 
                             + 
                             1 
                           
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             k 
                             - 
                             2 
                           
                         
                       
                       + 
                       … 
                       + 
                       
                         D 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     
                       S 
                       ~ 
                     
                     2 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         
                           i 
                           = 
                           0 
                         
                         
                           
                             i 
                             ≠ 
                             j 
                           
                           , 
                           , 
                           
                             i 
                             ≠ 
                             k 
                           
                         
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                       
                         D 
                         i 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               i 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         D 
                         0 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       
                         D 
                         
                           j 
                           - 
                           1 
                         
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               j 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     
                       
                         D 
                         
                           j 
                           + 
                           1 
                         
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               j 
                               - 
                               2 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       
                         D 
                         
                           k 
                           - 
                           1 
                         
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               k 
                             
                             ) 
                           
                         
                       
                     
                     + 
                   
                 
               
             
             
               
                 
                     
                    
                   
                     
                       
                         D 
                         
                           k 
                           + 
                           1 
                         
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               k 
                               - 
                               2 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         n 
                         - 
                         1 
                       
                     
                   
                 
               
             
           
         
       
     
         [0076]    Using the values of the stored reference checksums S 1 , S 2  and the current checksums {tilde over (S)} 1 , {tilde over (S)} 2 , the computing unit calculates the value of the damaged areas of the information zones according to the formulas: 
         [0000]        D   k =( S   2   +{tilde over (S)}   2 +( S   1   +{tilde over (S)}   1 ) a   n-j-1 )[ a   2(n-k-1)   +a   2(n-1)-j-k ] −1    
         [0000]        D   j   =S   1   +{tilde over (S)}   1   +D   k   a   n-k-1 ) a   −(n-j-1)    
         [0077]    The obtained values are recorded instead of the invalid. 
         [0078]    Consider now the case, when three blocks of the stripe are damaged which corresponds to the failure of three disks array. In addition, this recovery method is applied, if unrecoverable reading error occurs (UER) during the reconstruction of two failed disks, and consequently, three blocks are damaged. If the blocks of the control zones are damaged, then the computing unit calculates the current checksum that corresponds to the damaged control zones using the checksum calculation formulas. The obtained checksum values are recorded instead of the damaged. If one or two of the three damaged blocks belongs to the information zone and the remained one belongs to the control zone, the data is restored according to the scheme described above for one or two of the failed blocks and the value of the damaged control zone is calculated according to the formula of checksums calculation. 
         [0079]    blocks of the information zone be damaged, with their numbers j and k be discovered by the hardware 
         [0080]    Let D j , D k , D l  blocks of the information zone be damaged, with their numbers j, k and l be discovered by the hardware. Then, the current checksums {tilde over (S)} 0 , {tilde over (S)} 1 , {tilde over (S)} 2  are calculated using the computing unit with omitting the summands corresponding to the failed blocks: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       S 
                       ~ 
                     
                     0 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         
                           i 
                           = 
                           0 
                         
                         
                           
                             i 
                             ≠ 
                             j 
                           
                           , 
                           
                             i 
                             ≠ 
                             k 
                           
                           , 
                           
                             i 
                             ≠ 
                             l 
                           
                         
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                       D 
                       i 
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       D 
                       0 
                     
                     + 
                     
                       D 
                       1 
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         j 
                         - 
                         1 
                       
                     
                     + 
                     
                       D 
                       
                         j 
                         + 
                         1 
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         k 
                         - 
                         1 
                       
                     
                     + 
                     
                       D 
                       
                         k 
                         + 
                         1 
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         l 
                         - 
                         1 
                       
                     
                     + 
                   
                 
               
             
             
               
                 
                     
                    
                   
                     
                       D 
                       
                         l 
                         + 
                         1 
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         n 
                         - 
                         1 
                       
                     
                   
                 
               
             
           
         
       
       
         
           
             
                 
             
              
             
               
                 
                   
                     
                       
                         S 
                         ~ 
                       
                       1 
                     
                     = 
                       
                      
                     
                       
                         ∑ 
                         
                           
                             i 
                             = 
                             0 
                           
                           
                             
                               i 
                               ≠ 
                               j 
                             
                             , 
                             
                               i 
                               ≠ 
                               k 
                             
                             , 
                             
                               i 
                               ≠ 
                               l 
                             
                           
                         
                         
                           n 
                           - 
                           1 
                         
                       
                        
                       
                         
                           D 
                           i 
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             i 
                             - 
                             1 
                           
                         
                       
                     
                   
                 
               
               
                 
                   
                     = 
                       
                      
                     
                       
                         
                           D 
                           0 
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             1 
                           
                         
                       
                       + 
                       … 
                       + 
                       
                         
                           D 
                           
                             j 
                             - 
                             1 
                           
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             j 
                           
                         
                       
                       + 
                       
                         
                           D 
                           
                             j 
                             + 
                             1 
                           
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             j 
                             - 
                             2 
                           
                         
                       
                       + 
                       … 
                       + 
                       
                         
                           D 
                           
                             k 
                             - 
                             1 
                           
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             k 
                           
                         
                       
                       + 
                     
                   
                 
               
               
                 
                   
                       
                      
                     
                       
                         
                           D 
                           
                             k 
                             + 
                             1 
                           
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             k 
                             - 
                             2 
                           
                         
                       
                       + 
                       … 
                       + 
                       
                         
                           D 
                           
                             l 
                             - 
                             1 
                           
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             l 
                           
                         
                       
                       + 
                       
                         
                           D 
                           
                             l 
                             + 
                             1 
                           
                         
                          
                         
                           a 
                           
                             n 
                             - 
                             l 
                             - 
                             2 
                           
                         
                       
                       + 
                       … 
                       + 
                       
                         D 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     
                       S 
                       ~ 
                     
                     2 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         
                           i 
                           = 
                           0 
                         
                         
                           
                             i 
                             ≠ 
                             j 
                           
                           , 
                           
                             i 
                             ≠ 
                             k 
                           
                           , 
                           
                             i 
                             ≠ 
                             l 
                           
                         
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                       
                         D 
                         i 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               i 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         D 
                         0 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       
                         D 
                         
                           j 
                           - 
                           1 
                         
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               j 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     
                       
                         D 
                         
                           j 
                           + 
                           a 
                         
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               j 
                               - 
                               2 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       
                         D 
                         
                           k 
                           - 
                           1 
                         
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               k 
                             
                             ) 
                           
                         
                       
                     
                     + 
                   
                 
               
             
             
               
                 
                     
                    
                   
                     
                       
                         D 
                         
                           k 
                           + 
                           1 
                         
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               k 
                               - 
                               2 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       
                         D 
                         
                           l 
                           - 
                           1 
                         
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               l 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     
                       
                         D 
                         
                           l 
                           + 
                           1 
                         
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               l 
                               - 
                               2 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         n 
                         - 
                         1 
                       
                     
                   
                 
               
             
           
         
       
     
         [0081]    To restore the D j , D k , D l  blocks the computing unit solves the following system: 
         [0000]    
       
         
           
             
               
                 ( 
                 
                   
                     
                       1 
                     
                     
                       1 
                     
                     
                       1 
                     
                   
                   
                     
                       
                         a 
                         
                           n 
                           - 
                           j 
                           - 
                           1 
                         
                       
                     
                     
                       
                         a 
                         
                           n 
                           - 
                           k 
                           - 
                           1 
                         
                       
                     
                     
                       
                         a 
                         
                           n 
                           - 
                           l 
                           - 
                           1 
                         
                       
                     
                   
                   
                     
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               j 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               k 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               l 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                   
                 
                 ) 
               
                
               
                 ( 
                 
                   
                     
                       
                         D 
                         j 
                       
                     
                   
                   
                     
                       
                         D 
                         k 
                       
                     
                   
                   
                     
                       
                         D 
                         l 
                       
                     
                   
                 
                 ) 
               
             
             = 
             
               ( 
               
                 
                   
                     
                       
                         S 
                         0 
                       
                       + 
                       
                         
                           S 
                           ~ 
                         
                         0 
                       
                     
                   
                 
                 
                   
                     
                       
                         S 
                         1 
                       
                       + 
                       
                         
                           S 
                           ~ 
                         
                         1 
                       
                     
                   
                 
                 
                   
                     
                       
                         S 
                         2 
                       
                       + 
                       
                         
                           S 
                           ~ 
                         
                         2 
                       
                     
                   
                 
               
               ) 
             
           
         
       
     
         [0082]    The matrix of this system is the Vandermonde matrix. Since its determinant 
         [0000]        b   jkl =( a   n-k-1   +a   n-j-1 )( a   n-k-1   +a   n-l-1 )( a   n-j-1   +a   n-l-1 ) 
         [0083]    is not equal to 0, the system of equations can be resolved uniquely. 
         [0084]    Using the values of the stored reference checksums S 0 , S 1 , S 2  and the current checksums, {tilde over (S)} 0 , {tilde over (S)} 1 , {tilde over (S)} 2 , the computing unit calculates the values of the damaged areas of information zones according to the formula: 
         [0000]        D   l =[( S   0   +{tilde over (S)}   0 )( a   n-j-1   a   2(n-k-1)   +a   n-k-1   a   2(n-j-1) )+( S   1   +{tilde over (S)}   1 )( a   2(n-k-1)   +a   2(n-j-1) )+( S   2   +{tilde over (S)}   2 )( a   n-k-1   +a   n-j-1 )] b   jkl   −1    
         [0000]        D   k =( S   1   +{tilde over (S)}   1 +( S   0   +{tilde over (S)}   0 ) a   n-j-1   +D   l ( a   n-l-1   +a   n-j-1 ))( a   n-k-1   +a   n-j-1 ) −1    
         [0000]    
       
      
       D 
       j 
       =S 
       0 
       +{tilde over (S)} 
       0 
       +D 
       k 
       +D 
       l  
      
     
         [0085]    The obtained values are recorded instead of the invalid. 
         [0086]    In the process of using the storage device, an analysis of the recorded data in the presence of corruption can be performed. The corruption of the data, instead of failure or damage of part of the storage device, is not registered by the hardware, and so, the fact of damage and its location is unknown. For an array of hard disks, the data corruption can be detected by stripes. 
         [0087]    If the failed blocks do not exist in the stripe, then the corruption is defined by calculating the current checksum using a computing unit formula: 
         [0000]    
       
         
           
             
               
                 S 
                 ~ 
               
               0 
             
             = 
             
               
                 
                   ∑ 
                   
                     i 
                     = 
                     0 
                   
                   
                     n 
                     - 
                     1 
                   
                 
                  
                 
                   D 
                   i 
                 
               
               = 
               
                 
                   D 
                   0 
                 
                 + 
                 
                   D 
                   1 
                 
                 + 
                 … 
                 + 
                 
                   D 
                   
                     n 
                     - 
                     1 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     
                       S 
                       ~ 
                     
                     1 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         0 
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                       
                         D 
                         i 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           i 
                           - 
                           1 
                         
                       
                     
                   
                 
               
             
             
               
                 
                     
                    
                   
                     
                       
                         D 
                         0 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     + 
                     
                       
                         D 
                         1 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           2 
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         n 
                         - 
                         1 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     ( 
                     
                       
                         
                           ( 
                           
                             
                               
                                 ( 
                                 
                                   
                                     
                                       D 
                                       0 
                                     
                                      
                                     a 
                                   
                                   + 
                                   
                                     D 
                                     1 
                                   
                                 
                                 ) 
                               
                                
                               a 
                             
                             + 
                             
                               D 
                               2 
                             
                           
                           ) 
                         
                          
                         a 
                       
                       + 
                       … 
                       + 
                       
                         D 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     ) 
                   
                 
               
             
           
         
       
     
         [0088]    The computing unit compares each of this values with the stored checksums S 0 , S 1 , S 2 . 
         [0089]    If S 0 +{tilde over (S)} 0 =0 and S 1 +{tilde over (S)} 1 =0 and S 2 +{tilde over (S)} 2 =0, i.e. the current checksums are equal to the reference checksums, the data corruption cannot be detected and the computing device starts to analysis the next stripe. If this condition is not satisfied, then the number of the block stripe with the corrupted data should be identified using the computational unit. The following conditions are verified with the aid of the computing unit: 
         [0090]    If S 0 +{tilde over (S)} 0 ≠0 and S 1 +{tilde over (S)} 1 =0 and S 2 +{tilde over (S)} 2 =0, then data corruption has been occurred in the block of the stripe corresponding to the checksum S 0 . 
         [0091]    If S 0 +{tilde over (S)} 0 =0 and S 1 +{tilde over (S)} 1 ≠0 and S 2 +{tilde over (S)} 2 =0, then data corruption has been occurred in the block of the stripe corresponding to the checksum S 1 . 
         [0092]    If S 0 +{tilde over (S)} 0 =0 and S 1 +{tilde over (S)} 1 =0 and S 2 +{tilde over (S)} 2 ≠0, then data corruption has been occurred in the block of the stripe corresponding to the checksum S 2 . 
         [0093]    If none of the above mentioned conditions are met, the conclusion should be deduced that the data corruption has been occurred in a block that corresponds to the information zone. In this case, the number (position) of this block is determined by using the computing unit according to the formula: 
         [0000]        j=n− 1−log a ( S   1   +{tilde over (S)}   1 )( S   0   +{tilde over (S)}   0 ) −1  
 
         [0094]    Here log a  means the discrete logarithm to the base a of the element of the Galois field. 
         [0095]    When the number of the damaged block is determined, the computing unit restores the value of this block, as it is described above for the case of the presence of a single failed block. 
         [0096]    An analysis of the recorded data in the presence of corruption can be performed even if there was failure or damage of a part of the storage device. That is, prior to the recovery procedure for the failed or damaged parts of the storage device, the “healthy” data is analyzed for the presence of corruptions. The analyses of the presence of corruption and its correction is performed in order to ensure the correctness of the recovered data. The corrupted data, in contrast to the failure or damage of a part of the storage device, is not registered by the hardware, and so, the fact of damage and its location is unknown. For an array of hard disks, the data corruption can be detected by stripes. 
         [0097]    If a failed stripe block is the block of the checksum S 2  then to analyze a corruption presence, the current checksums {tilde over (S)} 0 , {tilde over (S)} 1  are calculated by using the computing unit by the formulas: 
         [0000]    
       
         
           
             
               
                 S 
                 ~ 
               
               0 
             
             = 
             
               
                 
                   ∑ 
                   
                     i 
                     = 
                     0 
                   
                   
                     n 
                     - 
                     1 
                   
                 
                  
                 
                   D 
                   i 
                 
               
               = 
               
                 
                   D 
                   0 
                 
                 + 
                 
                   D 
                   1 
                 
                 + 
                 … 
                 + 
                 
                   D 
                   
                     n 
                     - 
                     1 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     
                       S 
                       ~ 
                     
                     1 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         0 
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                       
                         D 
                         i 
                       
                        
                       
                         s 
                         
                           n 
                           - 
                           i 
                           - 
                           1 
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         D 
                         0 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     + 
                     
                       
                         D 
                         1 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           2 
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         n 
                         - 
                         1 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     ( 
                     
                       
                         
                           ( 
                           
                             
                               
                                 ( 
                                 
                                   
                                     
                                       D 
                                       0 
                                     
                                      
                                     a 
                                   
                                   + 
                                   
                                     D 
                                     1 
                                   
                                 
                                 ) 
                               
                                
                               a 
                             
                             + 
                             
                               D 
                               2 
                             
                           
                           ) 
                         
                          
                         a 
                       
                       + 
                       … 
                       + 
                       
                         D 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     ) 
                   
                 
               
             
           
         
       
     
         [0098]    The computing block compares these value with the stored reference checksums S 0 , S 1 . 
         [0099]    If (S 0 +{tilde over (S)} 0 =0 and S 1 +{tilde over (S)} 1 =0), i.e. the current checksums are equal to the reference checksums, so data corruption is not detected and the computing device proceeds to recover a failed block by calculating the checksum S 2 . If this condition is not performed, the block number of the stripe with corrupted data is identified using the computational unit. To do this, use the computing unit to verify the following conditions: 
         [0100]    If (S 0 +{tilde over (S)} 0 ≠0 and S 1 +{tilde over (S)} 1 =0), then data corruption has occurred in the block of the stripe corresponding to the checksum S 0 . 
         [0101]    If (S 0 +{tilde over (S)} 0 =0 and S 1 +{tilde over (S)} 1 ≠0), then data corruption has occurred in the block of the stripe corresponding to the checksum S 1 . 
         [0102]    If none of these conditions has been fulfilled, it can be concluded that data corruption has been occurred in a block corresponding to the information area. The number of this block is determined by using the computing unit according to the formula: 
         [0000]        j=n− 1−log a ( S   1   +{tilde over (S)}   1 )( S   0   +{tilde over (S)}   0 ) −1  
 
         [0103]    When the number of the damaged unit is defined, the computing unit restores the values of all the failed units, as is described above for the case of presence of two failed blocks of the stripe. 
         [0104]    If the failed block of stripe is that one with checksum S 1 , then to discover a corruption, the computing unit calculates the current checksum {tilde over (S)} 0 , {tilde over (S)} 2  by the formulas: 
         [0000]    
       
         
           
             
               
                 S 
                 ~ 
               
               0 
             
             = 
             
               
                 
                   ∑ 
                   
                     i 
                     = 
                     0 
                   
                   
                     n 
                     - 
                     1 
                   
                 
                  
                 
                   D 
                   i 
                 
               
               = 
               
                 
                   D 
                   0 
                 
                 + 
                 
                   D 
                   1 
                 
                 + 
                 … 
                 + 
                 
                   D 
                   
                     n 
                     - 
                     1 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     
                       S 
                       ~ 
                     
                     2 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         0 
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                       
                         D 
                         i 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               i 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         D 
                         0 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     
                       
                         D 
                         1 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               2 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         n 
                         - 
                         1 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     ( 
                     
                       
                         
                           ( 
                           
                             
                               
                                 ( 
                                 
                                   
                                     
                                       D 
                                       0 
                                     
                                      
                                     
                                       a 
                                       2 
                                     
                                   
                                   + 
                                   
                                     D 
                                     1 
                                   
                                 
                                 ) 
                               
                                
                               
                                 a 
                                 2 
                               
                             
                             + 
                             
                               D 
                               2 
                             
                           
                           ) 
                         
                          
                         
                           a 
                           2 
                         
                       
                       + 
                       … 
                       + 
                       
                         D 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     ) 
                   
                 
               
             
           
         
       
     
         [0105]    The computing unit compares with each other the appropriate current checksums {tilde over (S)} 0 , {tilde over (S)} 2  and the stored reference checksums S 0 , S 2 . 
         [0106]    If (S 0 +{tilde over (S)} 0 =0 and S 2 +{tilde over (S)} 2 =0), i.e. the current checksum is equal to the reference checksum, so the data corruption is not detected and the computing device is transferred to the recovery of a failed unit, i.e. the checksum S 1 . If this condition is not performed, then with the computational unit is the identification block of the stripe in which there was data corruption. To do this, using the computing unit checks the following conditions: 
         [0107]    If (S 0 +{tilde over (S)} 0 ≠0 and S 2 +{tilde over (S)} 2 =0), then data corruption has occurred in the block of the stripe corresponding to the checksum S 0 . 
         [0108]    If (S 0 +{tilde over (S)} 0 =0 and S 2 +{tilde over (S)} 2 ≠0), then data corruption has occurred in the block of the stripe corresponding to the checksum S 1 . 
         [0109]    If not one of these conditions has been fulfilled, it means that data corruption has occurred in a block corresponding to the information zone, the number of this block is determined by using the computing unit according to the formula: 
         [0000]        j=n− 1−(log a ( S   2   +{tilde over (S)}   2 )( S   0   +{tilde over (S)}   0 ) −1 )/2
 
         [0110]    When the number of the damaged block is defined, a computing unit restores the values of all failed blocks, as described above for two failed blocks of the stripe. 
         [0111]    If a checksum S 0  is the failed block of the stripe, then to analyze the presence of data corruption, the current checksums {tilde over (S)} 1 , {tilde over (S)} 2  are calculated by using the formulas: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       S 
                       ~ 
                     
                     1 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         0 
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                       
                         D 
                         i 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           i 
                           - 
                           1 
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         D 
                         0 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     + 
                     
                       
                         D 
                         1 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           2 
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         n 
                         - 
                         1 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     ( 
                     
                       
                         
                           ( 
                           
                             
                               
                                 ( 
                                 
                                   
                                     
                                       D 
                                       0 
                                     
                                      
                                     a 
                                   
                                   + 
                                   
                                     D 
                                     1 
                                   
                                 
                                 ) 
                               
                                
                               a 
                             
                             + 
                             
                               D 
                               2 
                             
                           
                           ) 
                         
                          
                         a 
                       
                       + 
                       … 
                       + 
                       
                         D 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     ) 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     
                       S 
                       ~ 
                     
                     2 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         0 
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                       
                         D 
                         i 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               i 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         D 
                         0 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     
                       
                         D 
                         1 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               2 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         n 
                         - 
                         1 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     ( 
                     
                       
                         
                           ( 
                           
                             
                               
                                 ( 
                                 
                                   
                                     
                                       D 
                                       0 
                                     
                                      
                                     
                                       a 
                                       2 
                                     
                                   
                                   + 
                                   
                                     D 
                                     1 
                                   
                                 
                                 ) 
                               
                                
                               
                                 a 
                                 2 
                               
                             
                             + 
                             
                               D 
                               2 
                             
                           
                           ) 
                         
                          
                         
                           a 
                           2 
                         
                       
                       + 
                       … 
                       + 
                       
                         D 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     ) 
                   
                 
               
             
           
         
       
     
         [0112]    The computing unit compares with each other the appropriate current checksums {tilde over (S)} 1 , {tilde over (S)} 2  and the stored reference checksums S 1 , S 2 . 
         [0113]    If (S 1 +{tilde over (S)} 1 =0 and S 2 +{tilde over (S)} 2 =0), i.e. the current checksums are equal to the reference checksums, so data corruption is not detected and the computing device proceeds to recover a failed block, that is, to calculate the checksum S 0 . If this condition is not performed, then number of the block stripe with the corrupted data is identified using the computational unit. 
         [0114]    The following conditions are verified with the aid of the computing unit: 
         [0115]    If (S 1 +{tilde over (S)} 1 ≠0 and S 2 +{tilde over (S)} 2 =0), then data corruption has occurred in the block of the stripe corresponding to the checksum S 1 . 
         [0116]    If (S 1 +{tilde over (S)} 1 =0 and S 2 +{tilde over (S)} 2 ≠0), then data corruption has occurred in the block of the stripe corresponding to the checksum S 2 . If not one of these conditions is met, it means that data corruption has occurred in a block corresponding to the information zone, the number of this block is determined by using the computing unit according to the formula: 
         [0000]        j=n− 1−log a ( S   1   +{tilde over (S)}   1 )( S   0   +{tilde over (S)}   0 ) −1  
 
         [0117]    When the number of the damaged block is defined, the computing unit restores the value of these blocks, as it is described above for one of the failed blocks of the stripe. 
         [0118]    If the failed block stripe is the block, which corresponds to D j  information zone, where j is the number of the damaged block in the stripe, it is known to us, because the failure is logged by the hardware. Then, the computing unit calculates the current checksums {tilde over (S)} 0 , {tilde over (S)} 1 , {tilde over (S)} 2  to discover the data corruption by the formulas: 
         [0000]    
       
         
           
             
               
                 S 
                 ~ 
               
               0 
             
             = 
             
               
                 
                   ∑ 
                   
                     i 
                     = 
                     0 
                   
                   
                     n 
                     - 
                     1 
                   
                 
                  
                 
                   D 
                   i 
                 
               
               = 
               
                 
                   D 
                   0 
                 
                 + 
                 
                   D 
                   1 
                 
                 + 
                 … 
                 + 
                 
                   D 
                   
                     n 
                     - 
                     1 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     
                       S 
                       ~ 
                     
                     1 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         0 
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                       
                         D 
                         i 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           i 
                           - 
                           1 
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         D 
                         0 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     + 
                     
                       
                         D 
                         1 
                       
                        
                       
                         a 
                         
                           n 
                           - 
                           2 
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         n 
                         - 
                         1 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     ( 
                     
                       
                         
                           ( 
                           
                             
                               
                                 ( 
                                 
                                   
                                     
                                       D 
                                       0 
                                     
                                      
                                     a 
                                   
                                   + 
                                   
                                     D 
                                     1 
                                   
                                 
                                 ) 
                               
                                
                               a 
                             
                             + 
                             
                               D 
                               2 
                             
                           
                           ) 
                         
                          
                         a 
                       
                       + 
                       … 
                       + 
                       
                         D 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     ) 
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     
                       S 
                       ~ 
                     
                     2 
                   
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         0 
                       
                       
                         n 
                         - 
                         1 
                       
                     
                      
                     
                       
                         D 
                         i 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               i 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         D 
                         0 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     
                       
                         D 
                         1 
                       
                        
                       
                         a 
                         
                           2 
                            
                           
                             ( 
                             
                               n 
                               - 
                               2 
                             
                             ) 
                           
                         
                       
                     
                     + 
                     … 
                     + 
                     
                       D 
                       
                         n 
                         - 
                         1 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     ( 
                     
                       
                         
                           ( 
                           
                             
                               
                                 ( 
                                 
                                   
                                     
                                       D 
                                       0 
                                     
                                      
                                     
                                       a 
                                       2 
                                     
                                   
                                   + 
                                   
                                     D 
                                     1 
                                   
                                 
                                 ) 
                               
                                
                               
                                 a 
                                 2 
                               
                             
                             + 
                             
                               D 
                               2 
                             
                           
                           ) 
                         
                          
                         
                           a 
                           2 
                         
                       
                       + 
                       … 
                       + 
                       
                         D 
                         
                           n 
                           - 
                           1 
                         
                       
                     
                     ) 
                   
                 
               
             
           
         
       
     
         [0119]    We introduce an auxiliary notation: 
         [0000]        U   1 =( S   0   +{tilde over (S)}   0 ) a   n-j-1   +S   1   +{tilde over (S)}   1    
         [0000]        U   2 =( S   0   +{tilde over (S)}   0 ) a   2(n-j-1)   +S   2   +{tilde over (S)}   2    
         [0000]        U   3 =( S   1   +{tilde over (S)}   1 ) a   n-j-1   +S   2   +{tilde over (S)}   2    
         [0120]    The computing unit verifies the following conditions to define a data corruption: 
         [0121]    If (U 1 =0 and U 2 =0), a corrupted data is not detected, and the failed block can be recovered, as it is described above for one of the failed block stripe. If this condition is not performed, then the number of the blocks stripe is identified with the corrupted data using the computational unit. To do this, by using the computing unit the following conditions are verified: 
         [0122]    If (U 1 ≠0 and U 2 ≠0 and U 3 =0), then data corruption has occurred in the block of the stripe, which corresponds to the checksum S 0 . 
         [0123]    If (U 1 ≠0 and U 2 =0 and U 3 ≠0), then data corruption has occurred in the block of the stripe, which corresponds to the checksum S 1 . 
         [0124]    If (U 1 =0 and U 2 ≠0 and U 3 ≠0), then data corruption has occurred in the block stripe, which corresponds to the checksum S 2 . 
         [0125]    If not one of these conditions is met, it means that the data corruption has occurred in a block that corresponds to the information zone, the number of this block is determined by using the computing unit according to the formula: 
         [0000]        k=n− 1−log a ( S   2   +{tilde over (S)}   2 +( S   1   +{tilde over (S)}   1 ) a   n-j-1 )( S   1   +{tilde over (S)}   1 +( S   0   +{tilde over (S)}   0 ) a   n-j-1 ) −1  
 
         [0126]    When the number of the damaged block is defined, the computing unit restores the values of all failed blocks, as it is described above for two failed blocks of the stripe. 
         [0127]    It may be observed, that the computing unit may be included in the storage device, i.e. to be a part of it, but it can be an external tool regarding this storage device, for example, when the process of work of a memory device is organized with several independent devices. Thus, in this case the external device can be a network server, managing the work of several databases, united by a served network. 
         [0128]    Another object of the present invention is a system containing the said storage device and a computing unit providing the said operation. 
       INDUSTRIAL APPLICABILITY 
       [0129]    The method and the system to recover records in the storage device solve the problem of data storage reliability according to modern and prospective storage devices. This invention allows systems of more than 24 TB, while recovering several simultaneously failed parts of a storage device and providing the ability to recover data not only in case of failure, but also in case of corruption.