Technique for maintaining consistent I/O processing throughput in a storage system

Patent metadata

Field	Value
Publication number	US-10235059-B2
Application number	US-201514955973-A
Country	US
Kind code	B2
Filing date	Dec 1, 2015
Priority date	Dec 1, 2015
Publication date	Mar 19, 2019
Grant date	Mar 19, 2019

Abstract

A technique maintains consistent throughput of processing of input/output (I/O) requests by a storage system when changing configuration of one or more Redundant Array of Independent Disks (RAID) groups of storage devices, such as disks, within the storage system. The configuration of a RAID group (i.e., RAID configuration) may be represented by RAID objects (e.g., reference-counted data structures) stored in a memory of the storage system. Illustratively, the RAID objects may be organized as a RAID configuration hierarchy including a top-level RAID object (e.g., RAID group data structure) that is linked (e.g., via one or more pointers) to one or more intermediate-level RAID objects (e.g., disk and segment data structures) which, in turn, are linked to one or more low-level RAID objects (e.g., chunk data structures). According to the technique, a snapshot of a current RAID configuration (i.e., current configuration snapshot) may be created by incrementing a reference count of the current top-level object of the hierarchy and attaching (e.g., via a pointer) the current configuration snapshot to a current I/O request processed by the storage system.

First claim

What is claimed is:

1. A method comprising:
receiving a plurality of write requests directed towards a logical unit (LUN), each write request having respective data and processed at a storage system connected to an array of storage devices;
organizing a set of the storage devices into a first redundancy group having a first redundancy configuration including a first storage device, the first redundancy group represented by a first redundancy group object having a first reference count indicating a number of pointers to the first redundancy group object, the first storage device represented by a storage device object referenced by a pointer included in the first redundancy group object;
associating a first write request with the first redundancy group object;
increasing the first reference count of the first redundancy group object;
processing the first write request; and
in response to completing processing of the first write request, decreasing the first reference count of the first redundancy group object.

2. The method of claim 1 further comprising:
in response to a failure of the first storage device,
creating a copy of the first redundancy group object into a second redundancy group,
removing the storage device object referenced from the copy of the first redundancy group object to create a second redundancy group object having a second redundancy configuration different from the first redundancy configuration,
associating a second write request with the second redundancy group object; and

processing the second write request using the second redundancy configuration.

3. The method of claim 2 wherein processing the first write request further comprises:
in response to an error communicating with the first storage device, re-associating the first write request with the second redundancy group object, and re-processing the first write request using the second redundancy configuration.

4. The method of claim 2 wherein each redundancy group is represented by a hierarchy of objects, and wherein the second redundancy group shares at least one object of its respective hierarchy of objects with the first redundancy group.

5. The method of claim 1 wherein each redundancy group is represented by a hierarchy of parent and child objects, each child object having a second reference count indicating a number of pointers to one or more parent objects.

6. The method of claim 5 wherein processing the first write request further comprises:
storing the respective data to the first storage device of the first redundancy configuration as a chunk represented by a chunk object, the chunk object included in the hierarchy of objects of the first redundancy group;
calculating redundant information based on the chunk; and
storing the redundant information to a second storage device of the first redundancy configuration.

7. The method of claim 1 wherein processing the first write request further comprises:
storing the respective data in a segment across the set of storage devices of the first redundancy configuration, wherein the segment has a log-structured layout.

8. The method of claim 1 further comprising:
in response to the first reference count of the first redundancy group object reaching a sentinel value, deleting the first redundancy group object.

9. The method of claim 1 wherein the storage devices are solid state drives.

10. A method comprising:
receiving a plurality of write requests directed towards a logical unit (LUN), each write request having respective data and processed at a storage system connected to an array of storage devices;
organizing a set of storage devices into a redundancy group having a first redundancy configuration represented by a redundancy group object having a reference count indicating a number of pointers to the first redundancy group object;
incrementing the reference count of the first redundancy group in response to creating a snapshot of the redundancy group;
associating a first write request with the snapshot of the redundancy group object;
in response to a failure of a storage device in the set of storage devices of the redundancy group,
updating the redundancy group object to remove the failed storage device so that the redundancy group is updated to have a second redundancy configuration different from the first redundancy configuration,
decrementing the reference count of the first redundancy group, associating a second write request with the redundancy group object;

processing the first write request according to the first redundancy configuration using the snapshot of the redundancy group; and
processing the second write request according to the second redundancy configuration using the updated redundancy group.

11. A system comprising:
a storage system having a memory connected to a processor;
a storage array coupled to the storage system and having one or more solid state drives (SSDs);
a storage I/O stack executing on the processor of the storage system, the storage I/O stack configured to:
receive a plurality of write requests directed towards a logical unit (LUN);
organize a set of the SSDs into a first redundancy group having a first redundancy configuration including a first SSD, the first redundancy group represented by a first redundancy group object having a first reference count indicating a number of pointers to the first redundancy group object, the first SSD represented by a storage device object referenced by a pointer included in the first redundancy group object;
associate a first write request with the first redundancy group object;
increase the first reference count of the first redundancy group object;
process the first write request; and
in response to completing processing of the first write request, decrease the first reference count of the first redundancy group object.

12. The system of claim 11 wherein the storage I/O stack is further configured to:
in response to a failure of the first SSD,
create a copy of the first redundancy group object into a second redundancy group,
remove the storage device object referenced from the copy of the first redundancy group object to create a second redundancy group object having a second redundancy configuration different from the first redundancy configuration,
associate a second write request with the second redundancy group object; and

process the second write request using the second redundancy configuration.

13. The system of claim 12 wherein the storage I/O stack configured to process the first write request is further configured to:
in response to an error communicating with the first SSD, re-associate the first write request with the second redundancy group object, and re-process the first write request using the second redundancy configuration.

14. The system of claim 12 wherein each redundancy group is represented by a hierarchy of objects, and wherein the second redundancy group shares at least one object of its respective hierarchy of objects with the first redundancy group.

15. The system of claim 12 wherein the storage I/O stack is further configured to process the first and second write requests without fencing.

16. The system of claim 12 wherein the first redundancy group is represented by a first hierarchy of objects and the second redundancy group is represented by a second hierarchy of objects, wherein the objects include a child object having a second reference count indicating a number of pointers to one or more parent objects, and wherein the second reference count is incremented for one or more objects of the s

Assignees

• Netapp Inc

Inventors

• Patel Chaitanya
• Shiwalkar Shailesh Ajay

Classifications

• G06F3/0644

  Management of space entities, e.g. partitions, extents, pools · CPC title

• G06F11/00

  Error detection; Error correction; Monitoring (error detection, correction or monitoring in information storage based on relative movement between record carrier and transducer G11B20/18; monitoring, i.e. supervising the progress of recording or reproducing G11B27/36; in static stores G11C29/00) · CPC title

• G06F3/0689

  Disk arrays, e.g. RAID, JBOD · CPC title

• G06F2201/84

  Using snapshots, i.e. a logical point-in-time copy of the data · CPC title

• G06F11/1076

  Parity data used in redundant arrays of independent storages, e.g. in RAID systems · CPC title