Creating a recovery copy from a source data copy in a repository that has source data at different points in time

Abstract

A system for maintaining source data in a repository, the system comprising: a processor; and a computer-readable storage medium having program instructions executed by the processor to perform operations, the operations comprising: Copying source data from a source to a repository at a first point in time; initiating point-in-time copies at different points in time of the source data after the first point in time, wherein for each of the point-in-time copies, change information is generated at the source indicating locations in the source data that have changed while the point-in-time copy was open; in response to completion of a previous point-in-time copy of the initiated point-in-time copies, transmitting to the repository a copy of the generated change information indicating locations in the source data that include data that was in the source data at a previous point in time before it was changed between a point in time of the previous point-in-time copy and a subsequent point in time at which a new point-in-time copy of the initiated point-in-time copies was created; Copying the changed point-in-time data that includes the source data in the source that is specified as changed in the generated change information for the point-in-time copy to the repository; Specifying a location (308) in changed data in the repository, wherein the changed point-in-time data for the previous point-in-time copy is specified in the copy of the generated change information (208) for the previous point-in-time copy, wherein the changed data of the repository comprises changed point-in-time data for a plurality of previous point-in-time copies specified in the copies of the generated change information for the previous point-in-time copies that were transferred to the repository; Receiving a restore request to restore the source data to a restore point in time; Determining the source data included in the generated change information for the previous point-in-time copies copied to the repository at the recovery time and retained in the changed data in the repository; and Copy the specific source data from the repository to a recovery copy.

Description

TECHNICAL APPLICATION SCOPE

[0001] The present invention relates to a computer program product, a system and a method for creating a recovery copy from a source data copy in a repository having source data at different points in time. STATE OF THE ART

[0002] In a storage environment, a storage controller can create point-in-time ("PiT") copies of a production volume using point-in-time copy techniques such as IBM® FlashCopy®, Snapshot, and so on. A point-in-time copy replicates data in a manner that appears instantaneous, allowing a host to continue accessing the source volume while postponing actual data transfers to the copy volume. The PiT copy appears instantaneous because a "complete" response is returned to the copy operation in response to the generation of relationship data structures, without copying any data from the source to the target volumes.PiT copy techniques typically delay the transfer of data in the source volume at the time the PiT copy relationship is defined to the copy target volume until a write operation is requested for that data block on the source volume. Data transfers must also occur as a background copy process with minimal impact on system performance. The PiT copy relationships, defined immediately in response to the PiT copy command, contain a bitmap or other data structure that specifies the location of the blocks on the volume, either on the source volume or the copy volume. The PiT copy comprises the combination of the data in the source volume and the data to be overwritten by the updates transferred to the target volume. IBM and FlashCopy are trademarks of International Business Machines Corporation, registered in many jurisdictions worldwide.

[0003] When an update is received to a block on the source volume involved in a PiT copy relationship, the copy of the track at that point in time must be copied to a replacement file or the target volume before the new data for the track is written to the source volume, overwriting the point-in-time copy of the data. Creating a recovery copy from a source data copy in a repository with source data at different points in time is complicated.

[0004] Therefore, the prior art requires a solution to the problem described above, even though considerable progress has already been made in this technical field. For example, document US 2009 / 0 307 286 A1 describes the creation of synthetic backup images on a remote computer system. The local computer system creates a full backup image and several incremental backup images. Additionally, the remote computer system receives the full backup image and several incremental backups from the local host computer. In this way, the remote computer system can create a synthetic backup image. Furthermore, document US 7 822 717 B2 describes point-in-time database recovery. For this purpose, a complete list of backup versions is requested from a backup server, identifying the most recent version, which is used to generate a command to completely restore a database.

[0005] Point-in-time copy and later point-in-time copy; for each point-in-time copy, copying the changed source data, including the source data specified as changed in the change information for the point-in-time copy, to the repository; receiving a restore request to restore the source data to a restore point in time; determining the source data in the repository at the restore point in time; and copying the determined source data from the repository to a restore copy.

[0006] Viewed from one aspect, the present invention provides a system for maintaining source data in a repository according to claim 1.

[0007] Viewed from another aspect, the present invention provides a method for managing source data in a repository according to claim 8.The method comprises the steps of: copying all source data into a repository at a first point in time; initiating point-in-time copies at different points in time of the source data subsequent to the first point in time; in response to the completion of each of the point-in-time copies, transmitting the repository change information indicating the data changed in the source data between the point-in-time copy time and a later time; for each point-in-time copy, copying the changed source data comprising the source data specified as changed in the change information for the point-in-time copy into the repository; receiving a restore request to restore the source data to a restore point in time; determining the source data in the repository at the restore point in time; and copying the determined source data from the repository to a restore copy.

[0008] Viewed from a further aspect, the present invention provides a computer program product for managing the source data in a repository according to claim 15, the computer program product comprising a computer-readable storage medium readable by a processing circuit and for storing the instructions for executing the processing circuit to perform a method for performing the steps of the invention.

[0009] Viewed from a further aspect, the present invention provides a computer program stored on a computer-readable medium and loadable into the internal memory of a digital computer, the computer program comprising, when executed on a computer, software code portions for carrying out the steps of the invention. BRIEF DESCRIPTION OF THE DRAWINGS

[0010] The present invention will now be described in more detail by way of example only with reference to the preferred embodiments as illustrated in the following figures: Fig. 1 illustrates an embodiment of the storage environment according to a preferred embodiment of the present invention; Fig. 2 illustrates an embodiment of the memory controller's point-in-time copy information according to a preferred embodiment of the present invention; Fig. 3 illustrates an embodiment of the repository's point-in-time copy information according to a preferred embodiment of the present invention; Fig. 4 illustrates one embodiment of operations for creating a repository with source data and point-in-time information of the source data at different points in time according to a preferred embodiment of the present invention; Fig. 5a, Fig. 5b and Fig. 5c illustrate examples of states of the source data and the repository at different times according to a preferred embodiment of the present invention; Fig. 6 illustrates an embodiment of the operations for creating a recovery copy according to a preferred embodiment of the present invention; Fig. 7 illustrates an embodiment of the operations for determining source data to copy into the recovery copy according to a preferred embodiment of the present invention; and Fig. Figure 8 illustrates a computing environment in which the components of Fig. 1 can be implemented according to the prior art and in which a preferred embodiment of the present invention can be implemented. DETAILED DESCRIPTION

[0011] The described embodiments provide techniques for creating a repository for maintaining a full copy of source data and point-in-time copies of the source data so that the source data can be restored from the repository at different points in time. OVERVIEW

[0012] Provided are a computer program product, system, and method for creating a restore copy of a source data copy in a repository having source data at different points in time. All source data at a first point in time is copied into a repository. Point-in-time copies are initiated at different points in time of the source data subsequent to the first point in time; in response to creating each of the point-in-time copies, transmitting change information to the repository indicating the data changed in the source data between the time of the point-in-time copy and a later time. For each point-in-time copy, changed source data that has the data specified as changed in the change information for the point-in-time copy is copied to the repository.A restore request is received to restore the source data to the restore point in time. The source data in the repository is determined at the restore point in time, and the determined source data is copied from the repository to a restore copy. "Restore" and "point in time" are the technical terms used for this purpose.

[0013] Viewed from a first aspect, the present invention provides a system for managing source data in a repository, comprising: a processor; and a computer-readable storage medium having program instructions executed by the processor to perform operations, the operations comprising: copying all source data into a repository at a first time; initiating point-in-time copies at different times of the source data subsequent to the first time; in response to the completion of each of the point-in-time copies, transferring to the repository repository change information indicating the data changed in the source data between the time of the point-in-time copy and a later time.In the described embodiments, the operations for managing the point-in-time ("PiT") copy information in the repository and performing the restore operations may be performed by a program component that is distinct from the storage controller logic that creates the PiT copies from the source data, so that the repository is maintained, used, and managed separately from the storage controller.

[0014] Fig. 1 illustrates one embodiment of the data storage environment including a storage controller 100 for managing access to a first storage 102 containing source data 104, such as a production disk used by various host systems. A host 106 includes a repository copy manager program 108 for managing the copying of the source data 104 to a repository 110 in a second storage 112. The storage controller 100, the host 106, and the second host 112 may communicate over a network 114.

[0015] The storage controller 100 includes a point-in-time ("PiT") copy manager 116 for creating point-in-time copies of the source data 104, e.g., FlashCopy, Snapshot, etc. When creating a PiT copy, the PiT copy manager 116 generates PiT copy information 200a on the PiT copy created at a point in time. The storage controller 100 further includes an operating system 118 that includes code and logic for managing the input / output ("I / O") requirements of the source data 104. The operating system 118 can configure the source data 104 on one or more volumes, and the data is stored in data units such as tracks, logical block addresses (LBAs), extents, etc. The PiT Copy Manager 116 may be a copy service provided by the operating system 118.

[0016] The memories 102 and 112 may store tracks in a Redundant Array of Independent Disks (RAID) configuration, where strides of the tracks are written across multiple storage devices comprising the memories 102 and 112. The memories 102 and 112 may each comprise one or more storage devices known in the art, such as interconnected storage devices, where the storage devices may include hard disk drives, solid-state storage (SSD) devices comprised of solid-state electronics such as an EEPROM (Electrically Erasable Programmable Read-Only Memory), flash memory, storage-class memory (SCM), etc., magnetic storage media, optical disks, tapes, etc.

[0017] The network 114 may include a network such as one or more interconnected local area networks (LANs), storage area networks (SANs), a wide area network (WAN), a peer-to-peer network, a wireless network, etc.

[0018] A PiT copy manager 116 performs a PiT copy operation that replicates the data in a manner that appears instantaneous, allowing a process to continue accessing the source volume while postponing actual data transfers to the copy volume. The PiT copy appears instantaneous because a "complete" response is returned to the copy operation in response to generating the relationship data structures without copying the data.

[0019] The repository copy manager 108 copies the source data 104 at various points in time into the repository 110, including an initial copy of all source data, and copies the PiT copy information 200 in the storage controller 100 into the repository 110 to store it as repository PiT copy information 300 in the repository 110. The repository copy manager 108 uses the PiT copy information 300 to determine the data changed in the one source data 104 to copy it into the change data 120 in the repository 110. To copy all source data to the repository 110 at a first time, the repository copy manager 108 may modify the change information for the first PiT copy or PiT bitmap, which has a bit for each data unit in the source data 104 indicating whether the data has been changed, to generate the modified first change information 2000' indicating that each data unit in the source data 104 has changed.The repository copy manager 108 can then copy all of the source data 104 specified in the modified first change information 2000 to the changed data 120 in the repository 110 to provide a complete copy of the source data 104 at the first time point in the repository. The repository copy manager 108 can use the change information in the PiT copy information 200 for PiT copies following the first time point to copy the changed data for different time points to the changed data 120 in the repository 110.

[0020] In the described embodiments, the repository copy manager 108 maintains a standalone full copy of the source data 104 and the PiT copy information 300 of the source data 104 in a separate storage 112, so that the data can be restored to different points in time independently of the source data 104 in the first storage 102 and the PiT copy information 200a in the storage controller 100. Thus, by enabling independent restoration of the source data 104, the repository 100 provides a redundant secure backup independent of the storage controller 100 to protect the storage controller 100 or the first storage 102 from failure.

[0021] In certain embodiments, the creation and management of the repository 110 is managed by a repository copy manager 108, which is separate from storage controller 100 programs, such as the PiT copy manager 116, that creates the PiT copies.

[0022] To generate the recovery copy 124, the repository copy manager 108 may use recovery copy information 130 that specifies the source data in the changed data 120 that must be copied into the recovery copy 124.

[0023] In the embodiment of Fig. 1, the repository creation and restore operations may be performed by program components, such as the repository copy manager 108, that are separate from the storage controller logic, such as the PiT copy manager 116, that created the PiT copies. In an alternative embodiment, the repository copy manager 108 and / or the repository 110 may be managed on the storage controller 100.

[0024] Fig. 2 illustrates an instance of the PiT copy information 200 i for the PiT copy at time T i, which may include information managed for copy information 200 of the storage controller, and may include a PiT copy identifier 202 that identifies the PiT copy created by the PiT copy manager 116 on the storage controller 100; a time 204 of the PiT copy 202, which may indicate that data is consistent at time 204; change information 206 that indicates which data or tracks have changed in the source data 104 since time 204 and while the PiT copy 202 is open, which may include a bitmap with one bit for each data unit (e.g., track) set to one of two values ​​indicating whether or not the data or track represented by the bit has been updated since time 204; and indicate the modified PiT data 208 having data at time 204 that was modified after time 204 while the PiT copy 202 was open and continued to be updated.PiT copy information can be managed for a first PiT copy created at the first time point T0 and for subsequent PiT copies created at later time points.

[0025] In one embodiment, the PiT copy may be completed or frozen at a time after time 204, such that the modified PiT data 208 includes data modified from time 204 until the completion or freezing of the PiT copy 202 or the initiation of a new PiT copy, and does not include any modified data after the completion, e.g., freezing, of the PiT copy 202. A PiT copy 202 may be completed with a freeze command or with the initiation of a subsequent PiT copy at a time later than time 204. A completed PiT copy 200 may be consistent at a time point. Other techniques may be used to complete, e.g., freeze, the PiT copy.

[0026] Fig. 3 illustrates an embodiment of an instance of the PiT copy information 300 managed in the repository 110 i , which consists of an instance of the PiT copy information 200 igenerated from the storage controller 100 and comprises a PiT copy identifier 302 for identifying the PiT copy 202 created by the PiT copy manager 116 in the storage controller 100; a time 304 of the PiT copy 302, which may mean that data is consistent at the time 304; change information 306 indicating which data or tracks in the source data 104 have changed since the time 304 and while the PiT copy 302 is open; which may comprise a bitmap; and a repository offset 308 indicating an offset in the changed data 120 at which the data specified in the change information 306 for the PiT copy 302 is located.The storage location of the changed data 120 of a particular changed data unit for a PiT copy 302 can be determined at an offset from the repository offset 308 in the changed data 120, such as by summing the repository offset 308 with the number of the changed unit specified in the change information 306, i.e., the jth data unit times a length of the data unit. In this way, the changed data from a PiT copy 300 is written to the repository sequentially after the last written data in the change data 120.

[0027] Fig. 4 illustrates one embodiment of the operations performed by the repository copy manager 108 and the PiT copy manager 116 to copy the source data 104 into the repository 110 at various times from the PiT copies for the source data 104, such as a production volume created by the PiT copy manager 116. Upon initiating (at block 400) the repository copy operations for the source data 104, the repository copy manager 108 sends (at block 402) a command to the PiT copy manager 116 to create a first PiT copy 2000 at a first time, referred to herein as T0. The repository copy manager 108 may modify the first change information 2000 to generate a modified first change 2000' indicating that all source data units in the source data have been changed.The repository copy manager 108 may (at block 406) send the modified first change information 2000' to the repository 110, indicating that all data units have been changed, and the changed PiT data 2080 for the first PiT copy (T0) specified in the modified first change information 2000', indicating all source data as changed. All source data at the first time point will be copied into the changed data 120 in the repository 110. The PiT copy 2000' from the storage controller 100 will be stored as PiT copy information 3000 with a repository offset 308 of 0, since the start of the data from the first PiT copy T0 is stored at the beginning of the changed data 120 in the repository 110.

[0028] The repository copy manager 108 may (in block 408) send a command to the PiT copy manager 116 to create a subsequent PiT copy (T i+1 ) at a later date T i+1to create what the PiT copy information 200 (i+1) In one embodiment, the repository copy manager 108 may send individual commands to the PiT copy manager 116 to create PiT copies and freeze a previously created PiT copy. In an alternative embodiment, the repository copy manager 108 may send a command to the PiT copy manager 116 instructing it to create PiT copies of the source data 104 at periodic intervals, with the creation of the subsequent PiT copy freezing the previously created PiT copy. Furthermore, the PiT copy manager 116 in the storage controller 100 may independently create PiT copies without request from the repository copy manager 108.

[0029] Upon determining (in block 410) that the previous point-in-time copy at T i is completed, the Repository Copy Manager 116 sends (in block 412) the PiT copy information 200 i for the PiT copy at time T i, including change information 206 i and the amended PiT data 208 i to the repository 110 for storage to PiT copy information 300 i for T i in the repository. In one embodiment, a PiT copy may be stored at time T i when creating the subsequent PiT copy at time T i+1 be completed. In an alternative embodiment, a PiT copy may be completed by issuing a Freeze command to freeze the PiT copy so that the change information 206 stops displaying the changes to the source data 104. The repository copy manager 108 creates (in block 414) PiT copy information 300 in the repository from the received PiT copy information 200. i .

[0030] The repository copy manager 108 may (in block 416) copy the source data 104 to a later time (T i+1) that have changed since the previous time are transferred to the changed data 120 in the repository 110 so that the complete copy is available for the later time T i+1 is updated. To perform this operation, a repository copy manager 108 can use the change information 206 for the previous PiT copy to send to T i determine that the data units in the source data 100 have changed and then copy these data units from the source data 104 to the changed data 120. In this way, for the later time T i+1 , if the subsequent PiT copy (T i+1 ) is created, data units in the source data 104 that occurred between the previous time T i and the later time T i+1 changed, copied to the changed data 120 in the repository 110.

[0031] The repository copy manager 108 may (in block 418) specify in the repository offset 308 the data unit offset in the changed data 120 at which the changed data for the PiT copy is to be T i If (in block 420) further point-in-time copies need to be created, then in the next iteration step, the repository copy manager 108 (in block 442) considers the current later point-in-time copy (T i+1 ) as a previous point-in-time copy to T i . In this way, i is effectively increased when the current later time T i+1 the previous time and a next time becomes the new later time. Control then returns to block 408 to create a new subsequent PiT copy (T i+1 ) at a new later time T i+1to create or process. If (in block 420) there are no more PiT copies to process, control ends.

[0032] In the described embodiments of Fig. 4, a repository 110 of a complete copy of the source data 104 with PiT copy information for various PiT copies is created independently of the operations of the storage controller 100 for creating the PiT copies. In this way, the logic or operations of the repository management operations are independent of the logic of the storage controller 100 for creating PiT copies.

[0033] Fig. 5a, Fig. 5b, Fig. 5c illustrate an example of the operations of Fig. 4 to copy all source data at different points in time into the changed data 120 and the repository PiT copy information 200b. Fig. 5a shows the state at a first time T0 of the source data 1040 in the source memory 102 being copied into the changed data 1200 in the repository 110, which may include all source data 104 at the first time T0. Furthermore, a copy of the PiT information 2000 at the first time T0 is created, which contains the change information 2060' indicating that all source data in the memory controller 100 has changed.

[0034] Fig. Figure 5b shows a time T1 at which a second PiT copy 2001 is created at T1, resulting in the completion or freezing of the previous PiT copy 2000 at T0 with changed data 2080 at time T0, before any changes occur between T0 and T1. The repository copy manager 108 copies the data changed between T0 and T1, represented as units 520 and 522, into the changed data 1201 in the repository 110 to update the changed data 1201 to the changed data 520, 522 at time T1 following the first written data. Furthermore, the completed or frozen PiT copy information 2000 is copied at T0 to the repository 110 for storage as PiT copy 3000, which has an offset 3080 of zero, since the source data for the first PiT copy 2000 is the first data written to the changed data 1201.

[0035] Fig. Figure 5c shows a time T2 at which a third PiT copy 2002 is created at T2, resulting in the completion or freezing of the previous PiT copy 2001 at T1 with changed data 2081 at time T1, before any changes occur between T1 and T2. The repository copy manager 108 copies the changed data between T1 and T2, as shown as 524 and 526, to the repository 110 to update the changed data 1202 to the data at time T2. Furthermore, the completed or frozen PiT copy information 2001 at T1 is copied to the repository 110 to be stored as repository PiT copy 3001, which includes a repository offset 3081 indicating the data unit offset in the repository 1202 at which the changed data 520 and 522 begin.

[0036] Fig. Figure 6 illustrates one embodiment of operations performed by the repository copy manager 108 to create a recovery copy 124 from the repository 110 at a recovery time (T R ) that specifies a point in time from one of the point-in-time copies 200 b of the repository. When processing (in block 600) a restore request to create a restore copy 124 of the source data at the restore time (T R), the restore copy manager 108 configures (at block 602) an empty restore copy 124 or a restore volume to which the data from the changed data 120 will be copied for restoration. The repository copy manager 108 determines (at block 604) source data to copy into the restore copy 124 that includes changed data units from the changed data 120 from the first PiT copy 2000, data copied as part of the first PiT copy, and each of the point-in-time copies at or before the restore time. If the same data units for the source data exist in multiple PiT copies 300, then the data units for the PiT copy closest to the restore time are included in the determined source data to be copied. The repository copy manager 108 then initiates (in block 606) an operation to copy the determined source data to the recovery copy 124.The repository copy manager 108 makes available (at block 608) the recovery copy 124 in response to the completion of copying the particular source data to provide a complete copy of the source data at the recovery time (T. R ).

[0037] Fig. 7 illustrates the embodiment of the operations for determining the source data in the changed data 120 in the repository 124 for copying the recovery copy 124, such as those in block 604 in Fig. 6. Upon initiating the operation (in block 700) to determine the source data to be copied from the changed data 120, the repository copy manager 108 initializes (in block 702) recovery copy information 130, such as a bitmap, that indicates all source data units as not copied into the recovery copy 124. T i is (in block 704) set to T RThe repository copy manager 106 determines (in block 706) the changed data units 120 for the PiT copy 300 i at time T i that are indicated in the recovery copy information 130 as not yet copied, for example with a bit value indicating that they have not yet been copied.

[0038] For each changed data unit determined in step 706, the repository copy manager 106 determines (in block 708) the location of the data unit in the repository from the repository offset 308 for the PiT copy at Ti (e.g., the changed data unit number plus the repository offset times a length of the data unit). In one embodiment, the repository offset 308 may provide information for the first changed data unit of the PiT copy, and the repository copy manager 108 must determine the offset for a particular data unit based on the number of the changed data unit, i.e., the number of times the PiT copy change information 306 i specified j-th changed data unit plus the repository offset 308 i , then the sum is multiplied by one data length unit. Alternatively, the repository offset 308 may specify the offset number in the changed data 120 for each changed data unit for PiT copies following the first PiT copy at T0.

[0039] For example, in an embodiment where the repository offset 308i comprises an offset where the changed data for the PiT copy at Ti begins in the changed data 120, the particular storage location may comprise the changed data unit number, which comprises the number in the order in which the data unit for the PiT copy at Ti was written, plus the repository offset 308i for the PiT copy at Ti, with this sum multiplied by the data unit length. For example, if the data unit is the third data unit for the PiT copy to Ti written to the changed data 120, and the data unit number offset at which the changed data for the PiT copy to Ti begins in the changed data 120 is 100, and the data unit length is 16 bytes, then the position of the data unit in the changed data 120 has the sum of three times 100 multiplied by 16, for example, (3+100)x16, which in the changed data 120 corresponds to 4800.Byte corresponds to.

[0040] The specific modified data units from the PiT copy 300 i , whose storage location in the changed data is determined in block 708, are copied (in block 710) into the recovery copy 124 from the determined storage locations, and the copied data units are indicated (in block 712) as copied in the restore copy information 130. If (in block 714) T i is equal to T0, then all PiT copies 300 must be at or before the recovery time (T R ) are considered and control ends. Otherwise, if T i is not equal to T0, that will be T i (in Block 716) on T i-1 set to go back to block 706 to create the next PiT copy 300 i-1 , which directly before the last viewed PiT copy 300 i The operations of Fig. 7, the changed data units from the PiT copies are determined based on the PiT copies that are closest to the recovery time in reverse chronological order. In this way, if multiple PiT copies provide changed data for the same source data unit, then the copied changed data originating from the PiT copy provides changed data for the data unit that is closest in time to the recovery time T R so that the recovery copy 124 has changed data 120 from the repository 110 at the recovery time T R be provided.

[0041] In the embodiment of Fig. 7, the changed data units for a PiT copy under consideration are copied before the next PiT copy is considered. In an alternative embodiment, all source data units to be copied from the various PiT copies may be determined before the changed data is copied to the recovery copy 124.

[0042] The described embodiments provide techniques for creating a repository with all source data units at a first point in time, including source data units that have changed between the PiT copies created from the source data 104. The repository further maintains PiT copy information of the PiT copies created from the source data 104. In the described embodiments, a restore copy volume may be created at a restore point in time from the changed data in the repository using the PiT copy information in the repository to determine the data changed at the restore point in time by considering the PiT copy information for PiT copies at or before the restore point in time.

[0043] The present invention may be a system, a method, and / or a computer program product. The computer program product may be a computer-readable storage medium (or media) having computer-readable program instructions embodied thereon for causing a processor to perform aspects of the present invention.

[0044] The computer-readable storage medium may be a tangible device capable of containing and storing instructions for use by an instruction execution device. The computer-readable storage medium may be, for example, but not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing.A non-exhaustive list of more specific examples of computer-readable storage media includes the following: a portable computer diskette, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or Flash memory), static random access memory (SRAM), portable compact disc read-only memory (CD-ROM), a digital versatile disk (DVD), a memory stick, a floppy disk, a mechanically encoded device such as punched cards or protruding structures in a groove on which instructions are recorded, and any suitable combination of the foregoing.A computer-readable storage medium, as used herein, should not be construed to mean inherently transient signals, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission media (for example, pulses of light passing through a fiber optic cable), or electrical signals transmitted over a cable.

[0045] Computer-readable program instructions described herein may be downloaded to corresponding computing / processing devices from a computer-readable storage medium or to an external computer or storage device over a network, for example, the Internet, a local area network, a wide area network, and / or a wireless network. The network may include copper transmission cables, fiber optic transmission cables, wireless transmission, routers, firewalls, switches, gateway computers, and / or edge servers. A network adapter card or network interface in each computing / processing device receives computer-readable program instructions from the network and forwards the computer-readable program instructions for storage on a computer-readable storage medium in the corresponding computing / processing device.

[0046] Computer-readable program instructions for performing operations of the present invention may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state-setting data, or other source code or object code written in any combination of one or more programming languages, including an object-oriented programming language such as Java ®, Small Talk, C++ or similar, and conventional procedural programming languages, such as the C programming language or similar programming languages. The computer-readable program instructions may execute entirely on the user's computer, partly on the user's computer as a standalone software package, partly on the user's computer and partly on a remote computer, or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer over any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, over the Internet using an Internet service provider).In some embodiments, an electronic circuit, including, for example, a programmable logic circuit, field-programmable gate array (FPGA), or programmable logic array (PLA), can execute computer-readable program instructions by using state information of the computer-readable program instructions to adapt the electronic circuit to perform various aspects of the present invention. Java and all Java-based trademarks and logos are trademarks or registered trademarks of Oracle and / or its affiliates.

[0047] Aspects of the present invention are described in this document with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It is understood that each block of the flowchart illustrations and / or block diagrams, and combinations of the blocks in the flowchart illustrations and / or block diagrams, may be implemented by computer-readable program instructions.

[0048] These computer-readable program instructions may be provided to a processor of a general purpose computer, a special purpose computer, or other programmable data processing device to produce a machine such that the instructions, executing via the processor of the computer or other programmable data processing device, create means for implementing the functions / acts specified in the flowchart and / or block diagram block(s).These computer-readable program instructions may also be stored on a computer-readable medium that can instruct a computer, other programmable data processing apparatus, and / or other devices to function in a particular manner, such that the computer-readable storage medium has instructions stored thereon that comprise a product that includes instructions that implement aspects of the function / operation specified in the flowchart and / or block diagram block(s).

[0049] The computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus, or other device to produce a computer-implemented process such that the instructions executing on the computer, other programmable apparatus, or other device implement the functions / acts specified in the flowchart and / or block diagram block(s).

[0050] The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of the systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in the flowcharts or block diagrams may represent a module, segment, or section of instructions comprising one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions specified in the block may not occur in the order indicated in the figures. For example, depending on the functionality included, two consecutive blocks may actually execute substantially concurrently, or blocks may sometimes execute in the reverse order.It should also be emphasized that each block of the block diagram and / or flowchart illustrations, and the combinations of blocks in the block diagram and / or flowchart illustrations, may be implemented by special purpose hardware-based systems that perform the specified functions or operations or that execute combinations of special purpose hardware and computer instructions.

[0051] The computing components of Fig. 1, including the memory controller 100 and the host 106, may be implemented in one or more computer systems, such as the one shown in Fig. 8. The computer system / server 802 may be described in the general context of computer-executable instructions, such as program modules executed by a computer system. In general, the program modules may include routines, programs, objects, components, logic, data structures, etc., that perform specific tasks or implement specific abstract data types. The computer system / server 802 may be executed in distributed cloud computing environments, where tasks are performed by processing devices at remote locations connected by a communications network. In a distributed cloud computing environment, the program modules may be located on storage media of both local and remote computer systems, including memory storage devices.

[0052] As in Fig. 8, a computer system / server 802 is depicted as a general computing device. The components of a computer system / server 802 may include, but are not limited to, one or more processors or processing units 804, a system memory 806, and a bus 808 that connects various system components, including the system memory 806, to the processor 804. The bus 808 represents one or more of any of various bus structure types using any of various bus architectures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, and a processor or local bus.These architectures include, but are not limited to, the Industry Standard Architecture (ISA) bus, the Micro Channel Architecture (MCA) bus, the Enhanced ISA (EISA) bus, the Video Electronics Standards Association (VESA) local bus, and the Peripheral Component Interconnects (PCI) bus.

[0053] The computer system / server 802 typically contains various computer-readable media. These media may be any available media accessible by the computer system / server 802, including both volatile and non-volatile media, removable and non-removable media.

[0054] System memory 806 may include computer system-readable media in the form of volatile memory, such as random access memory (RAM) 810 and / or cache memory 812. Computer system / server 802 may further include other removable / non-removable, volatile / non-volatile computer system storage media. As an example, storage system 813 may be provided for reading from and writing to non-removable, non-volatile magnetic media (not shown and typically referred to as a "hard drive"). Although not shown, a magnetic disk drive may be provided for reading from and writing to a removable, non-volatile magnetic disk medium (e.g., a "floppy disk"), and an optical disk drive may be provided for reading from or writing to a removable, non-volatile optical disk medium, such as a CD-ROM, DVD-ROM, or other optical medium.In such cases, each may be connected to bus 808 through one or more media data interfaces. As further illustrated and described below, memory 806 may contain at least one program product having a group of (e.g., at least one) program modules configured to perform the functions of embodiments of the invention.

[0055] For example, and not by way of limitation, a program / utility 814 having a group of (at least one) program modules 816 may be stored in memory 806, as may an operating system, one or more application programs, other program modules, and program data. Each of the operating system, one or more application programs, other program modules, and program data, or a particular combination thereof, may include an implementation of a network environment. The components of computer 802 may be implemented as program modules 816 that generally perform the functions and / or methodologies of the embodiments of the invention as described herein. The system of Fig. 1 may be implemented in one or more computer systems 802, where, when implemented in multiple computer systems 802, the computer systems may communicate over a network.

[0056] The computer system / server 802 may also communicate with one or more external devices 818, such as a keyboard, pointing device, display 820, etc.; one or more devices that enable a user to interact with the computer system / server 802; and / or any devices (e.g., network card, modem, etc.) that enable a computer system / server 802 to communicate with one or more other computing devices. Such communication may occur via input / output (I / O) interfaces 822. Further, a computer system / server 802 may communicate with one or more networks via a network adapter 824, such as a local area network (LAN), a general wide area network (WAN), and / or a public network (e.g., the Internet). As illustrated, the network adapter 824 communicates with the other components of the computer system / server 802 via the bus 808.It should be understood that, although not shown, other hardware and / or software components may be used in connection with computer system / server 802. Examples include, but are not limited to, microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data archiving storage systems, etc.

[0057] Devices communicating with each other do not need to be in constant communication unless explicitly stated otherwise. Furthermore, devices communicating with each other may communicate directly or indirectly through one or more intermediate components.

[0058] A description of an embodiment with various components communicating with each other does not imply that all such components are required. Rather, a variety of optional components are described to illustrate the wide variety of possible embodiments of the present invention.

[0059] Where a single device or article is described herein, it is readily apparent that more than one device / article (regardless of whether they cooperate with each other) may be used in place of a single device / article. Likewise, where more than one device or article is described herein (regardless of whether they cooperate with each other), it is readily apparent that a single device / article may be used in place of the more than one article or article, or a different number of devices / articles may be used in place of the number of devices or programs depicted. The functionality and / or features of a device may alternatively be performed by one or more other devices that are not explicitly described as having such functionality / features. Thus, other embodiments of the present invention need not include the device itself.

Claims

[1] A system for maintaining source data in a repository, the system comprising: a processor; and a computer-readable storage medium having program instructions executed by the processor to perform operations, the operations comprising: Copying source data from a source to a repository at a first point in time; initiating point-in-time copies at different points in time of the source data after the first point in time, wherein for each of the point-in-time copies, change information is generated at the source indicating locations in the source data that have changed while the point-in-time copy was open; in response to completion of a previous point-in-time copy of the initiated point-in-time copies, transmitting to the repository a copy of the generated change information indicating locations in the source data that include data that was in the source data at a previous point in time before it was changed between a point in time of the previous point-in-time copy and a subsequent point in time at which a new point-in-time copy of the initiated point-in-time copies was created; Copying the changed point-in-time data that includes the source data in the source that is specified as changed in the generated change information for the point-in-time copy to the repository; Specifying a location (308) in changed data in the repository, wherein the changed point-in-time data for the previous point-in-time copy is specified in the copy of the generated change information (208) for the previous point-in-time copy, wherein the changed data of the repository comprises changed point-in-time data for a plurality of previous point-in-time copies specified in the copies of the generated change information for the previous point-in-time copies that were transferred to the repository; Receiving a restore request to restore the source data to a restore point in time; Determining the source data included in the generated change information for the previous point-in-time copies copied to the repository at the recovery time and retained in the changed data in the repository; and Copy the specific source data from the repository to a recovery copy. [2] The system of claim 1, wherein the point-in-time copies are generated by a point-in-time copy program, and wherein a repository copy program executed separately from the point-in-time copy program performs the operations of transferring to the repository the copy of the generated change information and the changed point-in-time data indicated as changed in the copy of the generated change information. [3] The system according to any one of the preceding claims, wherein the operations further comprise: Specify a repository offset for each point-in-time copy in the repository to specify an offset in the repository to which the changed point-in-time data for the point-in-time copy is written. [4] The system of any preceding claim, wherein determining the source data in the repository at the time of recovery comprises: Determining source data in the repository at the recovery time, wherein if the repository has multiple instances of the changed point-in-time data for a data entity for different point-in-time copies, the determined source data comprises the changed point-in-time data for the data entity from the point-in-time copy closest to the recovery time. [5] The system of any preceding claim, wherein copying the source data at a first time comprises: Creating a point-in-time copy at the first point in time of the source data along with change information indicating that all source data has been changed; and Transfer a copy of the change information for the point-in-time copy to the repository at the first point in time. [6] The system of claim 5, wherein determining the source data in the repository at the recovery time for copying into the recovery copy comprises: Initialize the recovery copy information, indicating all source data as not copied to the recovery copy; for each point-in-time copy at or before the recovery time, starting with the point-in-time copy closest to the recovery time and considering the point-in-time copies in reverse chronological order, performing: Determining the changed point-in-time data for the point-in-time copy specified in the recovery copy information as not yet copied, wherein the determined changed point-in-time data is included in the determined source data to be copied; Using a repository offset for the point-in-time copy to determine a location (308) in the repository where the determined modified point-in-time data is stored; Copying the changed point-in-time data from the specified location in the repository to the recovery copy; and Specify in the recovery copy information the specific changed point-in-time data as copied. [7] The system according to any one of the preceding claims, wherein the operations further comprise: Configure a blank recovery disk to which the source data for the recovery copy is copied, where the recovery disk is available after the source data is copied from the repository to the recovery disk. [8] A method for maintaining source data in a repository, the method comprising: Copying source data from a source to a repository at a first point in time; initiating point-in-time copies at different points in time of the source data subsequent to the first point in time, wherein for each of the point-in-time copies, change information is generated at the source indicating locations in the source data that have changed while the point-in-time copy was open; in response to completion of a previous point-in-time copy of the initiated point-in-time copies, transmitting to the repository a copy of the generated change information indicating locations in the source data that include data that was in the source data at a previous point in time before it was changed between a point in time of the previous point-in-time copy and a subsequent point in time at which a new point-in-time copy of the initiated point-in-time copies was created; Copying the changed point-in-time data, which includes the source data in the source that is specified as changed in the generated change information for the point-in-time copy, to the repository; Specifying a location (308) in changed data in the repository, wherein the changed point-in-time data for the previous point-in-time copy is specified in the copy of the generated change information (208) for the previous point-in-time copy, wherein the changed data of the repository comprises changed point-in-time data for a plurality of previous point-in-time copies specified in the copies of the generated change information for the previous point-in-time copies that were transferred to the repository; Receiving a restore request to restore the source data to a restore point in time; Determining the source data included in the generated change information for the previous point-in-time copies copied to the repository at the recovery time and retained in the changed data in the repository; and Copy the specific source data from the repository to a recovery copy. [9] The method of claim 8, wherein the point-in-time copies are generated by a point-in-time copy program, and wherein a repository copy program executed separately from the point-in-time copy program performs the operations of transferring to the repository the copy of the generated change information and the changed point-in-time data indicated as changed in the copy of the generated change information. [10] The method according to any one of the preceding claims 8 or 9, wherein the operations further comprise: Specify a repository offset for each point-in-time copy in the repository to specify an offset in the repository to which the changed point-in-time data for the point-in-time copy is written. [11] The method of any one of claims 8 to 10, wherein determining the source data in the repository at the time of recovery comprises: Determining source data in the repository at the recovery time, wherein if the repository has multiple instances of the changed point-in-time data for a data entity for different point-in-time copies, the determined source data comprises the changed point-in-time data for the data entity from the point-in-time copy closest to the recovery time. [12] The method of any one of claims 8 to 11, wherein copying the source data at a first time comprises: Creating a point-in-time copy at the first point in time of the source data along with change information indicating that all source data has been changed; and Transfer a copy of the change information for the point-in-time copy to the repository at the first point in time. [13] The method of claim 12, wherein determining the source data in the repository at the recovery time for copying into the recovery copy comprises: Initialize the recovery copy information, indicating all source data as not copied to the recovery copy; for each point-in-time copy at or before the recovery time, starting with the point-in-time copy closest to the recovery time and considering the point-in-time copies in reverse chronological order, performing: Determining the changed point-in-time data for the point-in-time copy specified in the recovery copy information as not yet copied, wherein the determined changed point-in-time data is included in the determined source data to be copied; Using a point-in-time copy repository offset to determine a location in the repository where the particular changed point-in-time data is stored in the recovery copy; Copying the changed point-in-time data from the specified location in the repository to the recovery copy; and Specify in the recovery copy information the specific changed point-in-time data as copied. [14] The method according to any one of claims 8 to 13, wherein the operations further comprise: Configure a blank recovery disk to which the source data for the recovery copy is copied, where the recovery disk is available after the source data is copied from the repository to the recovery disk. [15] A computer program product for maintaining source data in a repository, the computer program product comprising: a computer-readable storage medium readable by a processing circuit and storing instructions for carrying out the method according to any one of claims 8 to 14 by the processing circuit. [16] A computer program stored on a computer-readable medium and loadable into the internal memory of a digital computer, comprising software code portions for performing the method of any one of claims 8 to 14 when the program is executed on a computer.

Images