CN102110154B - File redundancy storage method in cluster file system - Google Patents

Abstract

The invention provides a file redundancy storage method in a cluster file system. On the premise of ensuring data reliability and availability, data can be dynamically switched in different storage states. When the system storage resources are tight, the data can be stored in the mirroring mode to the redundant verification mode, which reduces the redundant space occupation and improves the space utilization rate. At the same time, the data is written and updated in the form of mirroring. For the write request of the client, it is not necessary to consider how to perform redundant calculation and redundant update in the redundancy check mode. The newly written data block is mirrored to the redundant storage management device, and the writing performance is relatively high. Compared with the redundant check method, it has been greatly improved. In addition, when a storage node fails, a combination of mirroring and redundancy check can be used to perform recovery operations to reduce the amount of calculation and improve the efficiency of data recovery.

Description

A file redundant storage method in a cluster file system

technical field

The invention relates to a data security guarantee mechanism of a shared storage system, in particular to a redundant storage method for files in a cluster system.

Background technique

In the data-centric information age, how to properly and effectively protect data is one of the core issues of storage systems. People can tolerate abnormal computer downtime, all application restarts, and even hardware damage, but they demand that information should never be lost. The most important task of the storage system is to ensure that the stored information will not be lost no matter what failure occurs, and try to provide high-quality data services without interruption. The destruction and loss of data information not only affects the business continuity of the enterprise, but even greatly threatens the survival of an organization.

In order to ensure the security of the data stored in the disks, those skilled in the art have proposed Redundant Array of Independent Disks (RAID) technology, which combines multiple disks into a disk array, and stores the information of other disks in each disk. Redundant information, so that when a certain disk in the array fails, the data on the failed disk can be restored according to the redundant information stored in other disks in the array. According to the realization principle, RAID can be divided into different levels, represented by RAID0-RAID7 respectively. There are great differences in the working modes of different levels of RAID systems. The more representative ones are RAID1 using mirroring mode and RAID5 using redundancy check mode.

A technology similar to the aforementioned RAID can also be used in a network storage system, and multiple storage nodes form a network RAID system. However, if a mirroring method similar to RAID1 is used, although the read and write performance is high, the space utilization rate is only 50%, and the cost performance of the entire system is relatively low. If a redundancy check method similar to RAID5 is used, the space utilization rate is increased, but the write performance, especially the lower write performance, is low.

How to provide an efficient data high reliability and high availability guarantee mechanism for a high-performance, large-capacity network-based storage cluster file system, that is, to maintain excellent performance and reduce the loss of redundant space, has become a research hotspot. At present, PanFS, a parallel file system of cluster storage manufacturer Panasas, implements a file-level redundant storage mechanism. Small files are stored in a mirroring mode similar to RAID1, while large files are stored in a redundancy check mode similar to RAID5, but PanFS still cannot solve the above problems. Problems that cannot be solved by traditional mirroring and redundancy check technologies.

Contents of the invention

The purpose of the present invention is to overcome the defects of the above-mentioned prior art, provide an efficient data high reliability and high availability guarantee mechanism for a high-performance, large-capacity network-based storage cluster file system, and reduce redundancy while maintaining excellent performance loss of space.

The purpose of the present invention is achieved through the following technical solutions:

The present invention provides a file redundancy storage method in a cluster file system, wherein, in the file system, files are stored in network storage nodes in the form of data slices, including the following storage states: State 1, data slices are stored in the form of mirror images Deposit; state 2, the data sheet is stored in a redundancy check mode; the method includes the following steps:

Read each data piece of the file in state 1;

Carry out redundancy calculation and generate redundancy check sheet;

Write the redundancy check piece to the file;

Release the storage space of each image data piece of the file;

Change state 1 to state 2.

According to the file redundancy storage method in the cluster file system of the preferred embodiment of the present invention, the redundancy check mode adopted by the storage state 2 is parity check.

According to the file redundancy storage method in the cluster file system in the preferred embodiment of the present invention, the steps of the method are executed by an application server serving as a client in the file system.

According to the file redundancy storage method in the cluster file system of the preferred embodiment of the present invention, the storage state of the file also includes state 3, wherein the original version of the data piece is stored in a redundancy check mode, and the new version of the data piece generated by the update is written to Store in mirror image;

The method also includes the steps of:

Keep the original version of the data piece in state 2 that has been written and updated unchanged, and generate a new version of the data piece;

Write the new version of the data piece to the corresponding storage node, and make a mirror backup to another storage node at the same time;

Change state 2 to state 3.

The file redundancy storage method in the cluster file system according to the preferred embodiment of the present invention also includes the following write update steps:

For data slices stored in the mirror mode, modify the data slices and their mirror images stored in the two storage nodes at the same time;

For the data slices stored in the redundancy check mode, keep the original version data slices stored in the redundancy check mode unchanged, and generate a new version of the data slices; write the new version of the data slices into the corresponding storage nodes, and do mirror backup at the same time to another storage node.

The file redundant storage method in the cluster file system according to the preferred embodiment of the present invention also includes the following steps:

Traverse the mirrored data slices of the file in state 3 in turn, and fill the original version of the data slice into the new version of the data slice and the mirrored data slice when a hole is encountered;

Replace the original version of the data piece with the new version of the data piece;

Release the storage space of the new version data piece and the redundancy check data piece;

Modify state 3 to 1.

The file redundancy storage method in the cluster file system according to the preferred embodiment of the present invention also includes a recovery step when the data piece is in error:

In state 1, use the data slice image on the corresponding node to restore the error data slice;

In state 2, redundant calculations are performed to restore erroneous data slices;

In state 3, if the error is the original version of the data piece, redundant calculations will be performed to restore the error data piece; if the error is the new version of the data piece or its mirror image data piece, the error data piece will be restored using the data piece image on the corresponding node .

Compared with the prior art, according to the file redundancy storage method in the cluster file system provided by the specific embodiment of the present invention, data can be dynamically switched in different storage states. For the write operation of the client, the data is written and updated by mirroring. For the write request of the client, there is no need to consider how to perform redundant calculation and redundant update. The newly written data block is mirrored to the redundant storage management device. The problem of low write performance caused by lowercase update in the redundancy check mode is avoided, and the write performance is greatly improved compared with the existing redundancy check mode. At the same time, when the system storage resources are tight, the non-write-active data can be converted into redundant verification storage. On the premise of ensuring data reliability and availability, the redundant space occupation is reduced and the space utilization rate is improved. In addition, when a storage node fails, the combination of mirroring and redundancy checks can be used to reduce the amount of calculation, improve the efficiency of data recovery, and ensure data reliability and availability.

Description of drawings

Embodiments of the present invention will be further described below with reference to the accompanying drawings, wherein:

FIG. 1 is a schematic diagram of an initial state in which no data is written to each storage node according to an embodiment of the present invention;

2 is a schematic diagram of a state 1 in which data slices are stored in a mirror image according to an embodiment of the present invention;

3 is a schematic diagram of a state 2 in which data slices are stored in a redundancy check mode according to an embodiment of the present invention;

4 is a schematic diagram of a state 3 in which the original version of the data piece is stored in a redundancy check mode according to an embodiment of the present invention, and the new version of the data piece generated by the write update is redundantly stored in a mirror image mode;

5 is a schematic diagram of writing and updating data slices in state 1 according to an embodiment of the present invention;

6 is a schematic diagram of a new version of the data piece being written and updated again in state 3 according to an embodiment of the present invention;

7 is a schematic diagram of the original version data piece being written and updated in state 3 according to an embodiment of the present invention;

8 is a schematic diagram of an error in a redundancy check slice in state 2 according to an embodiment of the present invention;

FIG. 9 is a schematic diagram of a data slice error in state 2 according to an embodiment of the present invention;

10 is a schematic diagram of an error in a redundancy check slice in state 3 according to an embodiment of the present invention;

Fig. 11 is a schematic diagram of an error in the original version of the data piece in state 3 according to an embodiment of the present invention;

Fig. 12 is a schematic diagram of an error in mirroring of a new version data piece in state 3 according to an embodiment of the present invention;

Fig. 13 is a schematic diagram of errors in both the original version data slice and the new version data slice in state 3 according to an embodiment of the present invention.

Detailed ways

In order to make the object, technical solution and advantages of the present invention clearer, the present invention will be further described in detail below through specific embodiments in conjunction with the accompanying drawings. It should be understood that the specific embodiments described here are only used to explain the present invention, not to limit the present invention.

In the embodiment of the present invention, the file system includes an application server, a metadata server, and multiple storage nodes, wherein the application server, as a client of the file system, executes file read and write operations. FIG. 1 is an initial state according to an embodiment of the present invention, each storage node (SN) has no data written. In the embodiment of the present invention, when the file is saved for the first time, the file is stored in the corresponding network storage nodes in the form of data slices, and at the same time, the data slices of each storage node are mirrored and backed up to other nodes to form redundant storage in the mirror mode, which improves data reliability. sex. The storage state of the file at this time is called state 1, as shown in FIG. 2 . FIG. 2 is state 1 according to an embodiment of the present invention, where data slices are stored in a mirror image. In this embodiment, only 3 storage nodes and 3 mirror nodes are used as an example, but in other embodiments, the number of storage nodes is not limited and can be any number.

In an embodiment of the present invention, the storage state of the file in the file system further includes state 2 as shown in FIG. 3 , and the data slices are stored in a redundancy check mode. In the present embodiment, the redundancy check mode adopts a parity check similar to RAID5, and in other embodiments, the redundancy check mode can also adopt other redundancy known to those skilled in the art such as Hamming code check. verification method.

In an embodiment of the present invention, the above-mentioned file storage status 1 can be converted to status 2 through the following steps, and the conversion steps include:

Read each data piece of the file in state 1;

Carry out redundancy calculation and generate redundancy check sheet;

Write the redundancy check piece to the file;

Release the storage space of each image data piece of the file;

Change state 1 to state 2.

The above steps can also be referred to as a downgrade operation. When a large number of files are saved in state 1 and mirrored, the redundancy of the file space reaches 100%. At this time, if the remaining storage resources of the system are relatively tight, the file can be downgraded to convert state 1 to state 2 and saved with redundancy check Files, freeing storage resources and reducing space occupation without reducing system reliability.

In the embodiment of the present invention, the downgrade operation is performed by the application server serving as the client in the file system, which can avoid the performance bottleneck of a single control node for centralized management. This degrading operation can be called by the background degrading daemon process (DegradeDeamon) to perform space compression and resource release when resources are tight. In some embodiments, the demotion operation may also be performed by the storage management server. In some other embodiments, the step of downgrading can be performed by the server in the file system.

In the embodiment of the present invention, the storage state of files in the file system also includes state 3 as shown in Figure 4, wherein the original version data slices are stored in a redundancy check mode, and the new version data slices generated by writing and updating are mirrored. way to store. When a file in state 2 is written and updated, the storage state of the file transitions from state 2 to state 3, including the following steps:

Keep the original version of the data piece in state 2 that has been written and updated unchanged, and generate a new version of the data piece;

Write the new version of the data piece to the corresponding storage node, and make a mirror backup to another storage node at the same time;

Change state 2 to state 3.

The above steps can also be collectively referred to as a write operation to state 2 . As shown in Figure 4, the file in state 2 is written and updated. Taking the write update data piece D ₁₀ as an example, the original old piece D ₁₀ is kept unchanged, and a new piece D ₁₁ is generated. At the same time, the new piece D ₁₁ is The mirror image D ₁₁ ′ is saved to another storage node to implement mirror backup to ensure data reliability. At this time, the storage state of the file is called state 3 .

In the embodiment of the present invention, when writing and updating files, different operations need to be performed according to different storage methods of data slices, including the following steps:

For data slices stored in the mirror mode, modify the data slices and their mirror images stored in the two storage nodes at the same time;

For the data slices stored in the redundancy check mode, keep the original version data slices stored in the redundancy check mode unchanged, and generate a new version of the data slices; write the new version of the data slices into the corresponding storage nodes, and do mirror backup at the same time to another storage node.

The above steps may be collectively referred to as a write update operation. Figure 5 is a schematic diagram of writing and updating data slices in state 1 in the embodiment of the present invention. In state 1, the data slices are stored in a mirror image. When writing and updating them, they need to be modified and stored in two storage nodes in a mirror image. The data slice and its mirror image can be modified in synchronous mode or asynchronous mode. Taking writing and updating data slice D ₁ as an example, update D ₁ to D ₁₂ , and at the same time update the image D ₁ ′ of another storage node to D ₁₂ ′. At this time, the data storage state is still state 1, and the above steps can also be referred to as a write update operation on state 1.

When writing and updating a file in state 3, it is necessary to distinguish the storage method of the data piece. The original version of the data piece is stored in the form of redundancy check, while the new version of the data piece generated by the write update is stored in the form of mirror image. Fig. 6 is the schematic diagram according to the embodiment of the present invention after the new version data slice is written and updated under state 3, wherein the new version data slice is stored in a mirror image mode, and the file in state 3 shown in Fig. 4 is written and updated to write Take updating D ₁₁ as an example, keep the original data piece D ₁₀ stored in the redundancy check mode unchanged, update D ₁₁ to D ₁₂ , and at the same time update the image D ₁₁ ′ of D ₁₁ on another storage node to D ₁₂ ′, mirror backup is realized, and the storage status is also status 3 at this time.

Fig. 7 is a schematic diagram of the original version data piece being written and updated under state 3 according to an embodiment of the present invention; wherein the original version data piece is stored in a redundancy check mode, and the file in state 3 as shown in Fig. 6 is written and updated, with Write and update D ₃₀ as an example, keep the original version of the data piece D ₃₀ unchanged, and generate a new version of the data piece D ₃₁ , and at the same time save the mirror image D ₃₁ ′ of the new version of the data piece D ₃₁ to another storage node to realize mirror backup. To ensure the reliability of the data. At this time, the storage state is also state 3.

read and write operations

In the embodiment of the present invention, the application server performs write and read operations as a client.

The client's read operation will not affect the consistency state of the file system, and will not affect the creation and maintenance of snapshots, so follow the normal process, as shown in steps (1), (2), and (3):

(1) The client requests the file layout relationship information layout from the server (that is, the file logical address to physical address mapping);

(2) The server queries relevant metadata and returns the corresponding layout;

(3) The client reads the data on the storage device through the returned layout.

The application server performs write operations as a client, as shown in steps (4), (5), and (6):

(4) The client requests layout information from the server;

(5) The server queries relevant metadata, returns the corresponding read-write layout, and reserves corresponding resources. The client reads and writes the device according to the returned layout, reads the content of the storage device according to the read-only layout, and writes the modified content into the storage device corresponding to the writable layout;

(6) The client submits the corresponding metadata information to the layout, and adds the reserved resource information to the metadata organization.

For read requests, after the client obtains the resource mapping address from the metadata server, it directly requests data from the storage node, and the performance is not affected by redundant storage; for write requests, the client does not need to consider redundant update issues, and only needs to use remote mirroring to The newly written data block is mirrored to the redundant storage management device, and the writing performance is greatly improved compared with the redundancy check method. In some embodiments, the client may further optimize the performance of the write operation by adopting techniques such as delayed write, write aggregation, and caching.

In the embodiment of the present invention, the storage state of the file can be converted from state 3 to state 1 through the following steps:

Traverse the mirrored data slices of the file in state 3 in turn, and fill the original version of the data slice into the new version of the data slice and the mirrored data slice when a hole is encountered;

Replace the original version of the data piece with the new version of the data piece;

Release the storage space of the new version data piece and the redundancy check data piece;

Modify state 3 to 1.

The above steps may also be referred to as an upgrade operation. In this embodiment, the application server acts as the client to perform the following operations: sequentially traverse the image data block' of the file in state 3, and if a hole is encountered, it means that no valid data has been written in the data block, indicating that the original version of the data block block ₀ has not been modified, and naturally no new version of the data piece block _i is generated; at this time, the original version of the data piece is filled and written into the new version of the data piece block _i and the mirrored data piece block';

Replace the original version of the data piece block ₀ with the new version of the data piece block _i , because at this time, the storage state 3 of the file needs to be converted to state 1, and only the data piece and its mirror image are retained;

Delete, clear and recycle the relevant information of the new version of the data piece block _i and the redundancy check data piece P; at the same time, modify the status 3 to 1;

The transition from state 3 to state 1 can be completed by sequentially performing upgrade operations on the files in state 3.

In this embodiment, the above-mentioned downgrade operation, write operation to state 2, write update operation, and upgrade operation are all performed by the application server serving as the client in the file system. In some other embodiments, the above operations may also be performed by a storage management server or a server in a file system.

In some embodiments of the present invention, a method for dynamically converting a file storage state is provided for a cluster file system, wherein the files in the file system include the following storage states:

State 1, data slices are stored in a mirror image;

State 2, data slices are stored in redundancy check mode;

State 3, the original version of the data piece is stored in the form of redundancy check, and the new version of the data piece generated by the write update is stored in the form of mirror image;

Described dynamic conversion method comprises the following steps:

State 1 enters state 1 after a write update operation;

State 1 enters state 2 after a downgrade operation;

State 2 enters state 3 through a write operation to state 2;

State 3 enters state 3 after a write update operation;

State 3 enters state 1 through an upgrade operation.

When the state is 1, the downgrade operation changes the data slices originally stored in the mirror mode to the redundancy check mode, and transitions to state 2. This operation usually occurs when system storage space resources are tight, and data can be compressed to free up storage space.

State 2 is converted to state 3 after a write operation to state 2. In state 3, the original redundantly stored data slice remains unchanged. When a write update operation is required, a new version of the data slice is directly generated and mirrored to save it , so that all write and update operations do not need to perform redundant calculations and redundant updates, thereby improving write performance.

When the storage state of the file is 3, if all or most of the data slices have performed the write update operation, then all or most of the data slices D _ij have already stored the image D _ij ' in another storage node, in fact Data is stored in a mirrored manner. The upgrade operation can be performed at this time. After the operation is complete, the storage state reverts to state 1.

When a storage node (SN) stops serving due to node failure (such as power failure, operating system error, etc.) or network failure (such as network connection interruption, etc.), resulting in data loss, the faulty device needs to be repaired or replaced. After the repair or replacement is completed, the client needs to use the recovery operation to restore the lost data to ensure the reliability of the data. In an embodiment of the present invention, the following steps are adopted when the data sheet is in error:

In state 1, use the data slice image on the corresponding node to restore the error data slice;

In state 2, redundant calculations are performed to restore erroneous data slices;

In state 3, if the error is the original version of the data piece, redundant calculations will be performed to restore the error data piece; if the error is the new version of the data piece or its mirror image data piece, the error data piece will be restored using the data piece image on the corresponding node .

The above steps may also be referred to as recovery operations. The restoration operation will be specifically described below with reference to accompanying drawings 8, 9, 10, 11, 12, and 13.

In the embodiment of the present invention, when the file is in state 1, for a small file, there may be only one data slice; for a large file, there may be several data slices distributed on different nodes, each A node stores mirrored copies. When the file is in state 1, the recovery operation only needs to restore the error data piece of the faulty node with the mirror image on the corresponding node.

In the embodiment of the present invention, the error data slice classification and recovery operations under state 2 are as follows:

As shown in Figure 8, in state 2, the recovery operation when the redundancy check piece P fails, it is necessary to read other data pieces D ₁ , D ₂ and D ₃ of the file for redundancy calculation and generate a new redundancy check Piece P. As shown in Figure 9, in state 2, the recovery operation when the data piece D ₃ fails requires reading other data pieces D ₁ , D ₂ and the redundancy check piece P in the redundancy group to perform redundancy calculations and generate a new Data piece D ₃ .

In the embodiment of the present invention, error data classification and recovery operations under state 3 are as follows:

As shown in Figure 10, in state 3, the recovery operation when the redundancy check piece P ₀ fails requires reading other original version data pieces D ₁₀ , D ₂₀ and D ₃₀ stored in the form of redundancy check for redundancy. Calculate and restore the redundancy check piece P ₀ . As shown in Figure 11, under state 3, the recovery operation when the original version data piece D ₃₀ makes an error requires reading other original version data pieces D ₁₀ , D ₂₀ and the redundancy check piece P for redundancy calculation and restoration of the data piece _D30 . As shown in FIG. 12 , in state 3, the recovery operation when the mirrored data piece D ₁₁ ′ is in error is to restore the mirrored data piece D _{11 ′} of the error node by using the data piece D ₁₁ of the non-errored node. As shown in Figure 13, in state 3, the recovery operation when the original version data piece D ₁₀ and the new version data piece D ₁₁ are in error is divided into two steps: first, it is necessary to read the file on the non-error node to check the redundancy For other stored original version data slices, perform redundancy calculation to restore the original version data slice D ₁₀ ; then restore the data slice D ₁₁ on the error node through the data slice D ₁₁ ′ saved in the mirror.

It can be seen that when a storage node fails, the combination of mirroring and redundancy check can also reduce the amount of redundant calculation and redundant update, and improve the efficiency of data recovery.

In the embodiment of the present invention, the above recovery operation is performed by the application server acting as the client in the file system. In some other embodiments, the above operations may also be performed by a storage management server or a server in a file system.

In some embodiments of the present invention, the storage state of the files in the file system can be: state 1, data slices are stored in RAID1 mode; state 2, data slices are redundantly stored in RAID5 mode; state 3, original version data Slices are stored redundantly in RAID5 mode, and new version data slices generated by write updates are stored in RAID1 mode.

Through the above-mentioned specific embodiments of the present invention, a method for providing an efficient, highly reliable and highly available guarantee mechanism for a cluster file system based on network storage, using a data redundancy mechanism combining mirroring and redundancy checks to ensure data reliability of the file system and usability. According to the file redundancy storage method provided by the embodiment of the present invention, the storage state of the data is dynamically converted: for the write operation of the client, the data is written and updated in a mirroring manner, and it is not necessary to consider how to perform a redundancy check in the write request of the client The problem of redundant computing and redundant update, the newly written data block is mirrored to the redundant storage management device, avoiding the problem of low write performance caused by lower-case update in redundant verification methods such as RAID5, and the write performance is greatly improved . At the same time, when the system storage resources are tight, the non-write-active data can be converted into redundant verification storage. On the premise of ensuring data reliability and availability, the redundant space occupation is reduced and the space utilization rate is improved.

It can be seen that the file redundancy storage method according to the embodiment of the present invention has a good space utilization rate, can effectively reduce redundant computing overhead, and improve system performance. At the same time, when the storage node fails, the combination of mirroring and redundancy check can be used to reduce the amount of calculation, improve the efficiency of data recovery, and ensure the reliability and availability of data.

Although the present invention has been described in terms of preferred embodiments, the present invention is not limited to the embodiments described herein, and various changes and changes are included without departing from the scope of the present invention.

Claims (6)

1. cluster file system file redundant storage method, said file system file leaves network storage node in the mode of data slice, comprises following store status:

State 1, data slice is deposited with the mirror image mode;

State 2, data slice is deposited with the redundancy check mode;

State 3, wherein the original version data slice is deposited with the redundancy check mode, writes the redaction data slice that renewal generates and deposits with the mirror image mode;

Said method comprising the steps of:

Read each data slice of the file of the state of being in 1;

Carry out redundant computation, generate the redundancy check sheet;

The redundancy check sheet is write file;

The storage space of each mirror image data sheet of releasing document;

Modification state 1 is a state 2;

It is constant that the original version data slice of the state that is in 2 of renewal is write in maintenance, generates the redaction data slice;

The redaction data slice is write corresponding memory node, do mirror back-up simultaneously to another memory node;

Modification state 2 is a state 3.

2. the file redundant storage method in the cluster file system according to claim 1 is characterized in that: said redundancy check mode is parity checking.

3. cluster file system file redundant storage method according to claim 1 is characterized in that: said method is carried out by the application server as client in the file system.

4. cluster file system file redundant storage method according to claim 1 is characterized in that: also comprise the following step of updating of writing:

To the data slice of depositing with the mirror image mode, revise data slice and the mirror image thereof that leaves two memory nodes in simultaneously;

To the data slice of depositing with the redundancy check mode, the original version data slice that maintenance is deposited with the redundancy check mode is constant, generates the redaction data slice; The redaction data slice is write corresponding memory node, do mirror back-up simultaneously to another memory node.

5. cluster file system file redundant storage method according to claim 1 is characterized in that said method is further comprising the steps of:

Traversal is in the mirror image data sheet of the file of state 3 successively, runs into the cavity, the original version data slice is filled write redaction data slice and mirror image data sheet;

The original version data slice is replaced with the redaction data slice;

The storage space of release new edition data sheet and redundancy check data sheet;

Modification state 3 is 1.

6. according to claim 1,4 or 5 described cluster file system file redundant storage methods, it is characterized in that: also comprise the recovering step when data slice is made mistakes:

During state 1, with the data slice image recovery error data sheet on the corresponding node;

During state 2, carry out the data slice that the redundant computation recovery makes mistakes;

During state 3,, then carry out redundant computation and recover to make mistakes data slice if what make mistakes is the original version data slice; If what make mistakes is redaction data slice or its mirror image data sheet, then with the data slice image recovery error data sheet on the corresponding node.

Images