Systems and methods for instantaneous cloning

• US 8,812,450 B1
• Filed: 02/28/2013
• Issued: 08/19/2014
• Est. Priority Date: 04/29/2011
• Status: Active Grant

• Current Assignee: NetApp, Inc.
• Original Assignee: NetApp, Inc.
• Inventors: Kesavan, Ram, Venketaraman, Sriram, Gupta, Mohit, Periyagaram, Subramaniam
• Primary Examiner(s): Casanova, Jorge A
• Application Number:
  US13/781,462
• Time in Patent Office: 537 Days
• Field of Search: 707/656, 707/657, 707/692
• US Class Current: 707/656
• CPC Class Codes: G06F 16/13 File access structures, e.g. distributed indices arrangements of input from, or output to, record carriers G06F3/06
• CPC Class Codes: G06F 16/16 File or folder operations, e.g. details of user interfaces specifically adapted to file systems
• CPC Class Codes: G06F 16/17 Details of further file system functions
• CPC Class Codes: G06F 16/183 Provision of network file services by network file servers, e.g. by using NFS, CIFS network file access protocols H04L67/1097
• CPC Class Codes: G06F 3/0617 in relation to availability
• CPC Class Codes: G06F 3/0619 in relation to data integrity, e.g. data losses, bit errors
• CPC Class Codes: G06F 3/0641 De-duplication techniques
• CPC Class Codes: G06F 3/065 Replication mechanisms
• CPC Class Codes: G06F 3/067 Distributed or networked storage systems, e.g. storage area networks [SAN], network attached storage [NAS]
• CPC Class Codes: G06F 3/0689 Disk arrays, e.g. RAID, JBOD

Abstract

Techniques to clone a writeable data object in non-persistent memory are disclosed. The writeable data object is stored in a storage structure in non-persistent memory that corresponds to a portion of a persistent storage. The techniques enable cloning of the writeable data object without having to wait until the writeable data object is saved to the persistent storage and without needing to quiesce incoming operations (e.g., reads and writes) to the writeable data object.

Claims

1. A method comprising:

storing a writeable data object in a non-persistent memory of a storage system;

cloning the writeable data object in the non-persistent memory without having to wait until the writeable data object is saved to a persistent storage and without having to pause incoming write operations on the writeable data object during said cloning; and

whereby cloning without having to pause the incoming write operations comprises;

receiving a client request for a write operation at the storage system to modify a first dirty portion of an in-memory version of a data object represented by a first reference pointer tree;

marking a node in the first reference pointer tree as a dirty node, wherein the dirty node represents the first dirty portion;

allocating a replacement pointer for the dirty node in response to receiving the client request, wherein allocating the replacement pointer includes allocating the replacement pointer from a per-processor cache bucket, the per-processor cache bucket including freed reference pointers spatially co-located in a reference pointer space of the storage system; and

creating a first clone of the data object, the first clone represented by a second reference pointer tree, the second reference pointer tree having the replacement pointer as a node.

2. The method of claim 1, further comprising accessing a clone data object created from the cloning when modifying the writeable data object.

3. The method of claim 1, further comprising deleting a clone data object created from the cloning when modifying the writeable data object.

4. A method comprising:

receiving a client request for a write operation at a storage system to modify a first dirty portion of an in-memory version of a data object represented by a first reference pointer tree;

marking a node in the first reference pointer tree as a dirty node, wherein the dirty node represents the first dirty portion;

allocating a replacement pointer for the dirty node in response to receiving the client request without having to wait until the in-memory version of the data object is saved to persistent storage, wherein allocating the replacement pointer includes allocating the replacement pointer from a per-processor cache bucket, the per-processor cache bucket including freed reference pointers spatially co-located in a reference pointer space of the storage system;

creating a first snapshot of the data object, the first snapshot represented by a second reference pointer tree, the second reference pointer tree having the replacement pointer as a node; and

re-allocating the per-processor cache bucket, when the cache bucket is fully used, by determining co-located reference pointers from a pointer reference count metadata file.

5. The method of claim 4, wherein creating the first snapshot includes determining a hierarchical reference count of a root node of the first reference pointer tree, wherein the hierarchical reference count is determined by incrementing a reference count for each node of the first reference pointer tree.

6. The method of claim 4, further comprising freeing an assigned pointer of the dirty node in response to receiving the client request without having to wait until the in-memory version of the data object is saved to the persistent storage.

7. The method of claim 6, wherein freeing the assigned pointer includes freeing the assigned pointer by placing the assigned pointer in a per-processor cache stage.

8. The method of claim 7, further comprising committing the per-processor cache stage asynchronously to the pointer reference count metadata file in memory when the per-processor cache stage is full.

9. The method of claim 6, wherein freeing the assigned pointer includes freeing the assigned pointer by placing the assigned pointer in a global cache stage, where the global cache stage is accessed with a lock for multiprocessor processing safety.

10. The method of claim 6, wherein freeing the assigned pointer causes freeing a physical volume block space corresponding to the assigned pointer.

11. The method of claim 6, wherein allocating the replacement pointer is executed by a first processor in a multiprocessor system;

and wherein freeing the assigned pointer is executed by a second processor in the multiprocessor system.

12. The method of claim 4, further comprising allocating asynchronously a physical volume block corresponding to the replacement pointer after the first snapshot is created.

13. The method of claim 12, wherein allocating the physical volume block includes storing a mapping of the replacement pointer to the physical volume block in a metadata map on an aggregate metadata layer of the storage system.

14. The method of claim 4, wherein the replacement pointer is unique across a metadata map of the storage system between reference pointers and physical block identifiers on a persistent storage device.

15. The method of claim 4, further comprising creating a second snapshot of the data object simultaneously with the creating of the first snapshot.

16. A storage server system comprising:

a persistent storage device including a persistent storage image of a data object;

a processor configured to store, in a non-persistent memory, an in-memory version of the data object represented by a first reference pointer tree, wherein a first dirty portion of the in-memory version is different from the persistent storage image and the first dirty portion is represented by a dirty node in the first reference pointer tree;

a front-end allocation module configured to allocate a replacement pointer for the dirty node in response to a client request to make the in-memory version different from the persistent storage image without having to wait until the in-memory version of the data object is saved to persistent storage, wherein the front-end allocation module is configured to allocate the replacement pointer from a per-processor cache bucket, the per-processor cache bucket including freed reference pointers spatially co-located in a reference pointer space of the storage system and wherein the front-end allocation module is configured to re-allocate the per-processor cache bucket, when the cache bucket is fully used, by determining co-located reference pointers from a pointer reference count metadata file; and

a snapshot module configured to create a first snapshot of the data object represented by a second reference pointer tree having the replacement pointer as a node in the second reference pointer tree.

17. The storage server system of claim 16, further comprising a consistency point module configured to allocate a physical volume block corresponding to the replacement pointer after the first snapshot is created.

18. The storage server system of claim 16, further comprising a front-end free module configured to free an assigned pointer of the dirty node in response to receiving the client request without having to wait until the in-memory version of the data object is saved to the persistent storage.