SYSTEM AND METHOD FOR REDUNDANCY-PROTECTED AGGREGATES

• US 20100180153A1
• Filed: 01/09/2009
• Published: 07/15/2010
• Est. Priority Date: 01/09/2009
• Status: Active Grant

• Current Assignee: NetApp, Inc.
• Original Assignee: NetApp, Inc.
• Inventors: Jernigan,, Richard P. IV, Hyer,, Robert Wyckoff JR., Kazar, Michael L., Nydick, Daniel S.
• Granted Patent: US 8,495,417 B2
• Time in Patent Office: Days
• US Class Current: 714/6
• CPC Class Codes: G06F 11/1076 Parity data used in redundant arrays of independent storages, e.g. in RAID systems
• CPC Class Codes: G06F 2211/1028 Distributed, i.e. distributed RAID systems with parity
• CPC Class Codes: G06F 2211/1045 Nested RAID, i.e. implementing a RAID scheme in another RAID scheme

Abstract

The present invention provides a system and a method for utilizing a parity protection module to back up data on striped aggregates. Specifically, the system computes party data for data stored at a particular location of each of a plurality of constituent aggregates, and stores the parity on one of the constituent aggregates that is a parity owner for that particular location of data. In the event one of the constituent aggregates fails, new data may still be accessed by the system (the striped aggregates), both to write new data, and to read data stored on the failed aggregate. In particular, the parity protection module allows clients to read data from a failed aggregate by running a reverse parity computation, which may also be used to restore the data to the failed aggregate.

Claims

1. A method, comprising:

organizing a plurality of constituent aggregates as striped aggregates, the constituent aggregates implemented across a plurality of nodes interconnected as a cluster, the constituent aggregates including one or more data aggregates and a parity owner aggregate;

storing data received from at least one client on each of the data aggregates;

computing redundancy information for data stored at a particular location of each of the data aggregates; and

storing the computed redundancy information on the parity owner aggregate for the particular location of data.

2. The method of claim 1, wherein computing the redundancy information further comprises:

writing the data, redundancy information and one or more identifiers to a non-volatile storage device of a node in the cluster; and

sending a response back to the client once the data has been written to the non-volatile device.

3. The method of claim 1, wherein storing the computed redundancy information on the parity owner aggregate further comprises:

writing one or more parity identifiers to a non-volatile storage device of the node on a cluster;

sending a first response back to a data aggregate;

writing the parity block to the party owner aggregate; and

sending a second response back to the data aggregate.

4. The method of claim 3, wherein the data aggregate is the aggregate that receives the data stored on the constituent aggregates.

5. The method of claims 4, further comprising:

determining that a data aggregate has failed after receiving a write request; and

in response to determining that the data aggregate has failed, initializing a procedure to read data from parity owner and any non-filled data aggregates.

6. The method of claim 5, further comprising:

sending a read request to the parity owner aggregate;

performing a reverse parity computation on a parity protection module of a node associated with the parity owner aggregate;

utilizing the reverse parity computation to read the data block for the failed aggregate; and

sending a read response to a broadcasting node on the cluster.

7. The method of claim 6, further comprising restoring the failed aggregate utilizing a rebuilding procedure.

8. The method of claim 1, wherein the constituent aggregates are organized according to a striped across implementing RAID implementation.

9. The method of claim 8, wherein the RAID implementation is a RAID 4 implementation.

10. A system for utilizing a striped data container to back up a storage system, the system comprising:

a first storage system servicing an aggregate interconnected to a plurality of constituent aggregates;

a second storage system servicing a parity owner aggregate, the parity owner interconnected with the plurality of constituent aggregates;

the fist storage system configured to;

(i) organize the plurality of constituent aggregates as striped aggregates, the constituent aggregates implemented across a plurality of nodes interconnected as a cluster, the constituent aggregates including one or more data aggregates and a parity owner aggregate;

(ii) store data received from at least one client on each of the data aggregates;

(iii) compute redundancy information for data stored at a particular location of each of the data aggregates; and

(iv) store the computed redundancy information on the parity owner aggregate for the particular location of data.

11. A computer program product that utilizes a striped aggregate to back up a storage system, comprising:

computer code that organizes a plurality of constituent aggregates as striped aggregates, the constituent aggregates implemented across a plurality of nodes interconnected as a cluster, the constituent aggregates including one or more data aggregates and a parity owner aggregate;

computer code that stores data received from at least one client on each of the data aggregates;

computer code that computes redundancy information for data stored at a particular location of each of the data aggregates;

computer code that stored the computed redundancy information on the parity owner aggregate for the particular location of data; and

a computer readable medium that stores the computer codes.

12. A method for utilizing a striped data container to back up a storage system comprising:

determining by a parity protection module executing on a node, whether any constituent aggregates have failed on a striped aggregate, the constituent aggregates implemented across a plurality of nodes interconnected as a cluster, the constituent aggregates including at least one data aggregate and a parity owner aggregate;

in response to determining that no failed aggregate is present in the striped aggregate, receiving a write request on an aggregate on the striped aggregate, the striped aggregate currently in normal mode;

writing a new data to a constituent data aggregate on the striped aggregate;

sending, in parallel to writing, a parity update request to the parity owner aggregate and a write response to a client; and

writing the parity update request to the parity owner aggregate.

13. The method of claim 12, the parity update request comprising an XOR of the new data and any old data for a block that is being modified.

14. A method for utilizing a striped data container to back up a storage system comprising:

determining by a parity protection module executing on a node, whether any constituent aggregates have failed on a striped aggregate, the constituent aggregates implemented across a plurality of nodes interconnected as a cluster, the constituent aggregates including one or more data aggregates and a parity owner aggregate;

in response to determining that there is only one failed constituent aggregate present in the cluster, determining a type of request;

in response to determining that the request is a read type request, determining whether the failed aggregate in the striped aggregate is required in order to read the data;

in response to determining that the failed aggregate is not required, reading the requested the requested data from the aggregate; and

returning a read response data to a client.

15. The method of claim 14, further comprising

in response to determining that the read request requires access to the failed aggregate, issuing, in parallel, a plurality of remote read requests to all the data aggregates on the striped aggregate;

reading the data from a corresponding storage device located on each data aggregate;

sending a read response back to a parity protection module on the failed aggregate, the parity protection module capable of computing a reverse parity XOR for all of the data received from the data aggregates;

computing a new parity XOR on the parity protection module; and

returning a read response to the client.

16. The method of claim 14, further comprising:

in response to determining that a write type request has been received on an available aggregate and that the parity owner aggregate is available for a target block of data, locking the target block of data on the data aggregate;

writing the data to a data aggregate on the striped aggregate; and

sending, in parallel to writing, a parity update request to the parity owner aggregate and a write response to a client;

locking a data block on the parity owner aggregate;

writing the parity update request to the parity owner aggregate.

unlocking the data blocks on the parity owner aggregate; and

unlocking the data blocks on the data aggregate.

17. The method of claim 14, further comprising:

in response to determining that a write type request has been received on an available aggregate, but the parity owner aggregate is the failed aggregate, writing the data only to the data aggregate without waiting for the parity owner aggregate to come back online.

18. The method of claim 14, further comprising:

in response to determining that a write type request has been received on a failed aggregate, but the parity owner aggregate is available, sending, from the parity protection module of the failed aggregate, a parallel remote read request to any available constituent data aggregates on the striped aggregate;

computing a new parity XOR on the failed aggregate'"'"'s parity protection module for all of the target data blocks and for the current write request;

writing the new parity along with a transaction ID to a Non-Volatile LOG (NVLOG) on the failed aggregate;

sending, in parallel, both a write response back to the client indicating that the write request has completed, and a write request to the parity owner aggregate; and

writing the computed parity data sent from the parity protection module to the parity owner aggregate as a new parity block.

19. A method comprising:

determining by a parity protection module executing on a node, whether any constituent aggregates have failed on a striped aggregate, the constituent aggregates implemented across a plurality of nodes interconnected as a cluster, the constituent aggregates including at least one data aggregates and a parity owner aggregate; and

in response to determining that there is more than one failed constituent aggregate in the striped aggregate, entering suspended mode until a quorum of aggregates agree that the striped aggregate no longer needs to be in suspended mode.