# Patent

## Title
Recording file events in change logs while incrementally backing up file systems

## Abstract

Recording file events in change logs while incrementally backing up file systems is described. A system begins incrementally backing up a file system by reading a current change log. The system identifies a file event associated with the file system while incrementally backing up the file system. The system identifies a unique identifier associated with the file event. The system determines whether the unique identifier associated with the file event is greater than a unique identifier offset associated with reading the current change log. The system records the file event in the current change log in response to a determination that the unique identifier associated with the file event is greater than the unique identifier associated with reading the current change log.

## Background
BACKGROUND
If a software error corrupts data, or if erroneous data updates the data, a data protection administrator may restore the data to a previous uncorrupted state that does not include the corrupted or updated erroneous data. A backup application executes a backup operation either occasionally or continuously to enable this restoration, storing a copy of each desired data state (such as the values of data and these values' embedding in a database's data structures) within dedicated backup files. If the data protection administrator decides to return the data to a previous state, the data protection administrator specifies the desired previous state by identifying a desired point in time when the data was in this state, and instructs the backup application to execute a restore operation to restore a copy of the corresponding backup files for that state to the data.
Performing a full backup of data can consume significant resources, especially when the backups are retained over time. Incremental backups reduce the amount of data backed up because an incremental backup only backs up changes that have been made to the data since the last backup. Identifying which data files, or data objects, have changed since the last backup may require a backup application or its agent to examine all of the data files and to analyze their change time stamps. However, larger file systems may have millions of data files, such that this examination and analysis can become a time consuming process and can degrade the file system's computing performance. Some backup applications trawl an entire file system to generate a list of changed files for incremental backups, but this trawling can consume significant resources. Other backup applications may take advantage of a file system's native change log as an alternative to trawling an entire file system.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 illustrates a block diagram of an example system recording file events in change logs while incrementally backing up file systems, under an embodiment;
FIG. 2 is an extremely simplified example of a bit map for recording file events in change logs while incrementally backing up file systems, under an embodiment;
FIG. 3 is an extremely simplified example of a inode data file for recording file events in change logs while incrementally backing up file systems, under an embodiment;
FIG. 4 is a flowchart that illustrates a method of recording file events in change logs while incrementally backing up file systems, under an embodiment; and
FIG. 5 is a block diagram illustrating an example hardware device in which the subject matter may be implemented.



DETAILED DESCRIPTION
Using a native change log for incremental backups can also result in degraded performance because a conventional change log temporally records every change that occurs to files in different change log records. For example, a change log records that a particular file is created in a first change log record, then records a large number of changes to the particular file in multiple change log records, and finally records that the particular file is deleted in a final change log record. Since a change log records changes for all files, the change log records for the particular file are interspersed with change log records for other files. During a backup of the file system, a backup application or its agent needs to process all of these change log records for the particular file even though this particular file is ultimately deleted. Consequently, the backup application or its agent identifies the particular file that was created and subsequently deleted when processing the change log record to create the particular file, resulting in an unnecessary disk access in an attempt to back up the particular file, because the backup application or its agent is not yet aware of the later change log record to delete the file. Unnecessary disk accesses may degrade the performance of the backup application, its agent, and/or the physical file system.
Since change logs store file change records in a temporal order, the file system needs to purge the change log at regular intervals or wrap the change log to ensure that the change log's size does not become too large. If a backup application does not process a change log before the change log is purged or wrapped around due to size constraints, the backup application needs to perform a full backup to ensure backup integrity, which may adversely affect the backup frequency because a file system with a high change rate may require full backups at frequent intervals due to concerns with the change log's size, thereby wasting resources.
U.S. application Ser. No. 14/042,304 filed Sep. 30, 2013, entitled “A Summary File Change Log for Faster Forever Incremental Backup”, which is hereby incorporated herein by reference, teaches a change log that uses unique identifiers that corresponds to each file, such as a file's corresponding index node number, to index a change log record for each changed file. Each file in a file system may be associated with a corresponding index node, or inode, which is a data structure that stores information about its corresponding file, such as file ownership, access mode, file type, size of the file, size of file at last backup, physical location, and timestamps, and is typically identified by a corresponding integer number. Every change to a particular file is stored in a single change log record for the particular file, which is indexed by the particular file's corresponding inode number. Therefore, a backup application or its agent can use a particular file's corresponding inode number to identify a complete set of changes to a particular file using a change log. For example, if a particular file was created, modified, and then removed, a backup agent uses the file system's inode numbers to discover all of this information in the change log in the same change log record, even though these events occurred at different times. Consequently, the backup agent does not need to generate an unnecessary disk access for the particular file that no longer exists. Additionally, the number of files that can be stored in a given file system depends on the number of defined inodes. Therefore, the change log has a bounded size which is determined by the total number of inodes in the file system. Consequently, the change log is proportional to the size of the file system and not proportional to the logical space of all of the large files present in the file system, such that the limited size change log does not need to be purged as regularly and does not need to wrap around.
At the end of each backup operation, a new change log is created to track subsequent changes to the file system for the subsequent backup operation. However, file changes which are detected during the backup operation may result in data loss, data duplication, and/or confusion. For example, if a backup agent detects a new file creation during a backup operation, the backup agent may ensure that a backup is created of the newly created file, but duplication may occur because the newly created file's sequence in the backup operation has not been processed yet. This duplication of effort results in two backup copies of the newly created file, the regularly processed copy of the newly created file and the backup agent-initiated copy of the newly created file, which wastes resources in duplication and creates confusion when restoring the newly created file. In another example, if a backup agent detects a new file creation during a backup operation, and the backup agent does not ensure that a backup is created of the newly created file, data loss may occur because the newly created file's sequence in the backup operation has already been processed. This results in no backup copies of the newly created file, which creates problems when attempting to restore the newly created file.
Embodiments herein record file events in change logs while incrementally backing up file systems. Incrementally backing up a file system is begun by reading a current change log. A file event associated with the file system is identified while incrementally backing up the file system. A unique identifier associated with the file event is identified. A determination is made whether the unique identifier associated with the file event is greater than a unique identifier associated with reading the current change log. The file event is recorded in the current change log in response to a determination that the unique identifier associated with the file event is greater than the unique identifier associated with reading the current change log. For example, a backup agent begins an incrementally back up of a file system by reading a current change log, and identifies a modification of a file in the file system while incrementally backing up the file system. The backup agent identifies an offset for the inode number 801 associated with the file modification, and determines whether the offset for the inode number 801 is greater than the offset for the current inode number being read in the current change log. The backup agent records the file modification in the current change log because the offset for the inode number 801 is greater than the offset for the current inode number 702 being read in the current change log, which means that the backup operation has not yet processed the record for inode number 801, such that the file modification is stored for processing by the current backup. If the backup agent identifies the offset for the inode number 600 associated with the file modification, the backup agent records the file modification in a new change log because the offset for the inode number 600 is not greater than the offset for the current inode number 702 being read in the current change log, which means that the backup operation has already processed the record for inode number 600, such that the file modification is stored for processing by the subsequent backup. The backup agent takes care to ensure that when file events detected when switching from the current change log to the new change log are recorded properly, thereby eliminating any associated data duplication and data loss.
FIG. 1 illustrates a block diagram of a system that implements recording file events in change logs while incrementally backing up file systems, under an embodiment. As shown in FIG. 1, system 100 may illustrate a cloud computing environment in which data, applications, services, and other resources are stored and delivered through shared data-centers and appear as a single point of access for the users. The system 100 may also represent any other type of distributed computer network environment in which servers control the storage and distribution of resources and services for different client users.
In an embodiment, the system 100 represents a cloud computing system that includes a first client 102, a second client 104, a third client 106; a fourth client 108; and a server 110 and a storage array 112 that may be provided by a hosting company. The clients 102-108 may be referred to as the desktop computer 102, the terminal 104, the laptop computer 106, and the mobile phone 108. The storage array 112 includes a first disk 114 and a second disk 116. The clients 102-108, the server 110, and the storage array 112 communicate via a network 118. Although FIG. 1 depicts the system 100 with four clients 102-108, one server 110, one storage array 112, two disks 114-116, and one network 118, the system 100 may include any number of clients 102-108, any number of servers 110, any number of storage arrays 112, any number of disks 114-116, and any number of networks 118. The clients 102-108 and the server 110 may each be substantially similar to the hardware device 500 described below in reference to FIG. 5.
The server 110 includes a backup application 120 and backups 122. FIG. 1 depicts the system elements 120-122 residing completely on the server 110, but the system elements 120-122 may reside completely on the clients 102-108, completely on another server that is not depicted in FIG. 1, or in any combination of partially on the server 110, partially on the clients 102-108, and partially on the other server. The first client 102 includes a backup agent 124, a current change log 126, which includes a current map file 128 and a current inode data file 130, and a new change log 132, which includes a new map file 134 and a new inode data file 136. FIG. 1 depicts the system elements 124-136 residing completely on the first client 102, but the system elements 124-136 may reside completely on any or all of the clients 102-108, completely on the server 110, completely on another server that is not depicted in FIG. 1, or in any combination of partially on the clients 102-108, partially on the server 110, and partially on the other server.
The backup application 120 may be, for example, EMC Corporation's NetWorker® backup application, which is a suite of enterprise level data protection software that unifies and automates backup to tape, disk-based, and flash-based storage media across physical and virtual environments for granular and disaster recovery. Cross-platform support is provided for many environments, including Microsoft Windows®. A central NetWorker® server manages a data zone that contains backup clients and NetWorker® storage nodes that access the backup media. The NetWorker® management console software provides a graphic user interface for functions such as client configuration, policy settings, schedules, monitoring, reports, and daily operations for deduplicated and non-deduplicated backups. The core NetWorker® software backs up client file systems and operating system environments. Add-on database and application modules provide backup services for products such as Microsoft® Exchange Server. Client backup data can be sent to a remote NetWorker® storage node or stored on a locally attached device by the use of a dedicated storage node. EMC Corporation's NetWorker® modules for Microsoft® applications supports Microsoft® products such as Microsoft® Exchange, Microsoft® Sharepoint, Microsoft® SQL Server, and Microsoft® Hyper-V servers. Although the functionality examples described in this paragraph apply to EMC Corporation's NetWorker® backup application, one of skill in the art would recognize that other backup applications and their corresponding functionalities may be used.
Although the following specifically describes the first client 102, the description applies equally to all of the clients 102-108. Data for the first client 102 is stored on the storage array 112 and/or on the first client 102. The backup agent 124 cooperates with the backup application 120 on the backup server 110 such that the data is backed up and that backups of the data are stored in the backups 122, which may include full and/or incremental backups of the data for the first client 102. The backup application 120 may provide the backup agent 124 to the first client 102, and the backup agent 124 may modify or replace the native change log in the first client 102 to create the system elements 126-136.
The backup agent 124 prepares for a subsequent backup operation after a current backup operation has concluded. The backup agent 124 manages the current change log 126 as the backup agent 124 continually detects file events. Detecting file events may rely on notifications from a layered file system positioned above a physical file system, such that all file events pass through or are detected by the layered file system and can be reported and processed. The current change log 126 may be a sparse file and may be formatted such that the size of the current change log 126 is bounded by associating the current change log 126 with inodes. As a result, the size of the current change log 126 is bounded by number of inodes in a given file system or by the potential number of inodes in use. Since the size of the current change log 126 is limited to the largest inode number present in the file system, and since file systems reuse inode numbers, the size of the current change log 126 is thus limited. Therefore, the current map file 128 and the current inode data file 130 in the current change log 126 may be instantiated as sparse files that do not need to be purged as regularly and that do not need to wrap around.
The current map file 128 is a bitmap file that identifies the corresponding inode number for each file that was modified in the file system since the last backup of the file system. For example, after the data file that corresponds to the inode number 701 is modified, then the current map file 128 contains a “1” for the 701st bit in the current map file 128. The current inode data file 130 identifies the actual changes that happen to each data file in the file system and corresponding metadata. For example, the current inode data file 130 may store the old file name, the new file name, the corresponding inode number (which can be used to index the inode-records), the file modification event (create, modify, remove, set attribute, etc.), file size, or the like or combination thereof in a record for a given data file. A data file may be associated with a record in the current inode data file 130, which may also be accessed according to the data file's corresponding inode number.
The file event (file removal, deletion, or modification) is reflected in the corresponding record of the current inode data file 130. If a data file in the file system is removed, a bit corresponding to the data file's inode number is set in the current map file 128, and the corresponding record in the current inode data file 130 contains the full file name in an old file name section to indicate the name of the file that was removed. If a file is created in the file system, then a bit corresponding to the data file's inode number is set in the current map file 128, and the current inode data file 130 contains the full file name in an new file name section to indicate the name of the file that was created. If a file is modified in the file system, then a bit corresponding to the data file's inode number is set in the current map file 128, and the corresponding record in the current inode data file 130 contains a flag or other metadata indicating that the file was modified along with the data file name. All of these examples can be accomplished by ensuring that the records which are stored in the current inode data file 130 are indexed by their corresponding inode number.
The current change log 126 maintains all modifications to any data file at one corresponding location in the current inode data file 130. This enables the backup agent 124 to read one record in the current inode data file 130 to know everything about a data file. For example, if a data file was created, modified, and then removed since a most recent backup, the backup agent 124 finds the corresponding bit set for the data file's corresponding inode number in the current map file 128, and uses the data file's corresponding inode number to index into the current inode data file 130 and read the corresponding record, which contains information indicating that the data file was created, modified and removed. When the backup agent 124 processes the corresponding-record in the current inode data file 130, the backup agent 124 can determine from the corresponding record that the file no longer exists and the backup agent 124 no longer issues a disk access request for a file that has been removed.
A backup operation can be initiated automatically by the backup agent 124, the backup server 110, the backup application 120, by a user, or the like. When performing an incremental backup, the backup operation may be initiated according to a predetermined schedule. The backup agent 124 accesses the current map file 128 to generate a list of files, or portions thereof, which may need to be included in the current backup. The current map file 128 includes a bit for every file and its corresponding inode number in the file system and those inodes whose corresponding bits are set are evaluated for being backed up in the current backup operation. While the current map file 128 identifies the specific files that have been modified since the last backup of the file system, the current inode data file 130 identifies the events that occurred with the file and enable the backup agent 124 to determine whether the file should be backed up. The current map file 128 also serves as an index to the current inode data file 130 that is used during the backup operation. Then the backup agent 124 processes the current inode data file 130 for each file in the list to determine whether to back up a file, as the file may have been removed and there is no longer a need to back up the file in the current backup. Each record in the current inode data file 130 presents the complete history of events that have occurred since the last backup for a corresponding file, such that each record enables the corresponding file to be handled appropriately.
The backup agent 124 begins incrementally backing up a file system by reading a current change log. For example, the backup agent 124 begins an incremental back up of a file system by reading the current change log 126 in an order based on an increasing sequence of inode offsets, because the current change log 126 records file events which occurred since a most recent back up of the file system. Since a conventional change log temporally records every change that occurs to files in different change log records, the identifiers of files in the change log records may appear to be in a random order, such as 34, 9876, 8642, and 297, unlike the current change log 126 which stores records in the current inode data file 130 based on an increasing sequence of inode offsets, such as the offset for the inode number 700, the offset for the inode number 701, the offset for the inode number 702, etc. As the backup agent 124 incrementally backs up files, the offset for reading the next record in the current inode data file 130 is increased. This offset may be referred to as the backup offset, and it gets incremented as the backup progresses.
After beginning the backup of a file system, the backup agent 124 identifies a file event associated with the file system while incrementally backing up the file system. For example, the backup agent 124 identifies a modification of a particular file in the file system while incrementally backing up the file system. Having identified a file event which occurred during the backup of a file system, the backup agent 124 identifies unique identifier associated with the file event. For example, the backup agent 124 identifies the inode number 801 associated with the file modification.
After identifying a unique identifier for a file event which occurred during the backup of a file system, the backup agent 124 determines whether the unique identifier for the file event is greater than a unique identifier associated with reading the current change log. For example, the backup agent 124 determines whether the offset for the inode number 801 is greater than the offset for the current inode number being read in the current change log 126.
If the unique identifier for the file event is greater than the unique identifier associated with reading the current change log, the backup agent 124 records the file event in the current change log. For example, the backup agent 124 records the file modification in the current change log 126 because the offset for the inode number 801 is greater than the offset for the current inode number 702 being read in the current change log 126, which means that the backup operation has not yet processed the record for the inode number 801, such that the file modification is stored for the processing by current backup. Consistency of the change logs 126 and 132 is maintained such that if a file that has yet to backed up is changed, the backup agent 124 records the file event in the current change log 126. If the unique identifier for the file event is not greater than the unique identifier associated with reading the current change log, the backup agent 124 records the file event in a new change log. For example, if the backup agent 124 identifies the offset for the inode number 600 associated with the file modification, the backup agent 124 records the file modification in the new change log 132 because the offset for the inode number 600 is not greater than the offset for the current inode number 702 being read in the current change log 126, which means that the backup operation has already processed the record for inode number 600, such that the file modification is stored for processing by the subsequent backup. Consistency of the change logs 126 and 132 is maintained such that if a file that is already backed up is changed, the backup agent 124 records the file event in the new change log 132. The backup agent 124 takes care to ensure that when file events detected when switching from the current change log to the new change log are recorded properly, thereby eliminating any associated data duplication and data loss.
The backup agent 124 may record subsequent file events to a new change log and delete the current change log after incrementally backing up the file system is completed. For example, the backup agent 124 records subsequent file events to the new change log 132 and deletes the current change log 126 after incrementally backing up the file system is completed. At this point, the new change log 132 becomes the current change log 126 for the next incremental backup.
FIG. 2 illustrates an example of the current map file 128 that is included in the current change log 126 in FIG. 1. FIG. 2 illustrates an mode-bitmap file 200, which includes multiple bits that can be set to 0 or 1. Each of the bits 202 in the mode-bitmap file 200 corresponds to corresponding inode numbers 204 in an inode number list 206. Although FIG. 2 depicts a single bit per inode number, there may be multiple bits that correspond to each inode number. A corresponding bit may be set when an event occurs with respect to a data file based on the data file's corresponding inode number, such that each entry in the mode-bitmap file 200 that is set reflects a file event, such as create, modify, remove, set attribute, etc., that occurred since the last backup. The mode-bitmap file 200 requires minimal space to reference each inode number in a file system because the mode-bitmap file 200 requires only a single bit for each corresponding inode number, making storage of and reference to the inode-bitmap file 200 quick and efficient.
The details of the file event that corresponds to a bit set in the inode-bitmap file 200 may be found in the current inode data file 130. However, it may not be necessary to record every event in the current inode data file 130. For example, writes to a newly created data file could be omitted since the data file's status as newly created will cause the data file to be included in the next backup. By accessing the current inode data file 130 using the inode-bitmap file 200, the backup agent 124 can quickly and efficiently identify which files in the file system have been changed and might need to be backed up.
The inode-bit map 200 can be purged and all bits reset after an incremental backup. Alternatively, a separate inode-bitmap could be used for the next backup, such as the new map file 134 in the new change log 132. Thus, when a backup is initiated, the system 100 may switch to another inode-bitmap file, such as the new map file 134. However, the current inode data file 130 does not need to be purged as frequently because all changes since the most recent backup can be identified using the inode-bitmap file 200. Alternatively, when a backup is initiated, the system 100 may switch to another inode-data file, such as the new inode data file 136 in the new change log 132.
FIG. 3 illustrates an example of the current inode data file 130 that is included in the current change log 126 used in performing backup operations. The inode-data file 300 includes multiple records, such as records 302, 304, and 306. Since there is a one to one correspondence between the number of records in the inode-data file 300 and the number of inodes in a system, the size of the inode-data file 300 is bounded by the number of inodes and the inode-data file 300 is not susceptible to becoming too large and does not need to wrap around like a conventional change log. In addition, the inode-data file 300 may be a sparse file, which further conserves on space.
The records 302-306 in the inode-data file 300 includes fields that store, by way of example and not limitation, an old file name 308, a new file name 310, an event mask 312, a file size 314, or the like. The old file name 308 stores the name of a file that was deleted, such that when a file is removed, the full name of the file is stored in the old file name 308. When an inode is reused or created, the name of the file that corresponds to the inode number is stored in the new file name 310. The event mask 312 denotes a set of operations that were performed against the file, and these events may be listed in chronological order. The file size 314 stores the size of the file at the time of the last backup, which can be used to track appending writes to the file. An example of an inode record may be as follows:

    Old File Name: /mnt1/dir1/file1
    New File Name: /mnt1/dir3/file4
    Event Mask: DELETE|CREATE|SETATTR
    Last Backup Size: 0
    Inode Number: 0x454fd


An example interpretation of this example inode record is that the file was originally /mnt1/dir1/file1, but has been removed, which reflected in the DELETE recorded in the event mask. Later, the inode (number 0x454fd) was reused for a new file named /mnt1/dir3/file4, which explains the CREATE recorded in the event mask. Subsequently, the owner and permissions of the new file were changed, which explains the SETATTR recorded in the event mask. The last backup size is 0 since no backup exists for the new file relative to the most recent backup.
The mode-data file 300 can also be purged in certain circumstances, such as after a backup operation. Alternatively, the system may switch to a different mode-data file, such as the new inode data file 136 in the new change log 132, once a backup operation is initiated.
FIG. 4 is a flowchart that illustrates a method for recording file events in change logs while incrementally backing up file systems under an embodiment. Flowchart 400 illustrates method acts illustrated as flowchart blocks for certain steps involved in and/or between the clients 102-108 and/or the server 110 of FIG. 1.
The backup agent 124 begins incrementally backing up a file system by reading a current change log, block 402. For example, the backup agent 124 begins an incrementally back up of a file system by reading the current change log 126. After backup of the file system has begun, the backup agent 124 identifies a file event associated with a file system while incrementally backing up the file system, block 404. For example, the backup agent 124 identifies a modification of a particular file in the file system while incrementally backing up the file system.
Having identified a file event which occurred during backup of a file system, the backup agent 124 identifies a unique identifier associated with the file event, block 406. For example, the backup agent 124 identifies the offset for the inode number 801 associated with the file modification. After identifying a unique identifier for a file event which occurred during backup of a file system, the backup agent 124 determines whether the unique identifier for the file event is greater than a unique identifier associated with reading a current change log, block 408. For example, the backup agent 124 determines whether the offset for the inode number 801 is greater than the offset for the current inode number being read in the current change log 126. If the unique identifier for the file event is greater than the unique identifier associated with reading the current change log, the flowchart 400 continues to block 410. If the unique identifier for the file event is not greater than the unique identifier associated with reading the current change log, the flowchart 400 proceeds to block 412.
If the unique identifier for the file event is greater than the unique identifier associated with reading the current change log, the backup agent 124 records the file event in the current change log, block 410. For example, the backup agent 124 records the file modification in the current change log 126 because the offset for the inode number 801 is greater than the offset for the current inode number 702 being read. Then the flowchart 400 proceeds to block 414. If the unique identifier for the file event is not greater than the unique identifier associated with reading the current change log, the backup agent 124 records the file event in a new change log, block 412. For example, the backup agent 124 records the file modification in the new change log 132 because the offset for the inode number 600 is not greater than the offset for the current inode number 702 being read. The backup agent 124 optionally records subsequent file events to a new change log and deletes the current change log after incrementally backing up the file system is completed, block 414. For example, the backup agent 124 records subsequent file events to the new change log 132 and deletes the current change log 126 after incrementally backing up the file system is completed.
Although FIG. 4 depicts the blocks 402-414 occurring in a specific order, the blocks 402-414 may occur in another order. In other implementations, each of the blocks 402-414 may also be executed in combination with other blocks and/or some blocks may be divided into a different set of blocks.
Having describing the subject matter in detail, an exemplary hardware device in which the subject matter may be implemented shall be described. Those of ordinary skill in the art will appreciate that the elements illustrated in FIG. 5 may vary depending on the system implementation. With reference to FIG. 5, an exemplary system for implementing the subject matter disclosed herein includes a hardware device 500, including a processing unit 502, a memory 504, a storage 506, a data entry module 508, a display adapter 510, a communication interface 512, and a bus 514 that couples elements 504-512 to the processing unit 502.
The bus 514 may comprise any type of bus architecture. Examples include a memory bus, a peripheral bus, a local bus, etc. The processing unit 502 is an instruction execution machine, apparatus, or device and may comprise a microprocessor, a digital signal processor, a graphics processing unit, an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), etc. The processing unit 502 may be configured to execute program instructions stored in the memory 504 and/or the storage 506 and/or received via the data entry module 508.
The memory 504 may include a read only memory (ROM) 516 and a random access memory (RAM) 518. The memory 504 may be configured to store program instructions and data during operation of the hardware device 500. In various embodiments, the memory 504 may include any of a variety of memory technologies such as static random access memory (SRAM) or dynamic RAM (DRAM), including variants such as dual data rate synchronous DRAM (DDR SDRAM), error correcting code synchronous DRAM (ECC SDRAM), or RAMBUS DRAM (RDRAM), for example. The memory 504 may also include nonvolatile memory technologies such as nonvolatile flash RAM (NVRAM) or ROM. In some embodiments, it is contemplated that the memory 504 may include a combination of technologies such as the foregoing, as well as other technologies not specifically mentioned. When the subject matter is implemented in a computer system, a basic input/output system (BIOS) 520, containing the basic routines that help to transfer information between elements within the computer system, such as during start-up, is stored in the ROM 516.
The storage 506 may include a flash memory data storage device for reading from and writing to flash memory, a hard disk drive for reading from and writing to a hard disk, a magnetic disk drive for reading from or writing to a removable magnetic disk, and/or an optical disk drive for reading from or writing to a removable optical disk such as a CD ROM, DVD or other optical media. The drives and their associated computer-readable media provide nonvolatile storage of computer readable instructions, data structures, program modules and other data for the hardware device 500.
It is noted that the methods described herein can be embodied in executable instructions stored in a computer readable medium for use by or in connection with an instruction execution machine, apparatus, or device, such as a computer-based or processor-containing machine, apparatus, or device. It will be appreciated by those skilled in the art that for some embodiments, other types of computer readable media may be used which can store data that is accessible by a computer, such as magnetic cassettes, flash memory cards, digital video disks, Bernoulli cartridges, RAM, ROM, and the like may also be used in the exemplary operating environment. As used here, a “computer-readable medium” can include one or more of any suitable media for storing the executable instructions of a computer program in one or more of an electronic, magnetic, optical, and electromagnetic format, such that the instruction execution machine, system, apparatus, or device can read (or fetch) the instructions from the computer readable medium and execute the instructions for carrying out the described methods. A non-exhaustive list of conventional exemplary computer readable medium includes: a portable computer diskette; a RAM; a ROM; an erasable programmable read only memory (EPROM or flash memory); optical storage devices, including a portable compact disc (CD), a portable digital video disc (DVD), a high definition DVD (HD-DVDTM), a BLU-RAY disc; and the like.
A number of program modules may be stored on the storage 506, the ROM 516 or the RAM 518, including an operating system 522, one or more applications programs 524, program data 526, and other program modules 528. A user may enter commands and information into the hardware device 500 through the data entry module 508. The data entry module 508 may include mechanisms such as a keyboard, a touch screen, a pointing device, etc. Other external input devices (not shown) are connected to the hardware device 500 via an external data entry interface 530. By way of example and not limitation, external input devices may include a microphone, joystick, game pad, satellite dish, scanner, or the like. In some embodiments, external input devices may include video or audio input devices such as a video camera, a still camera, etc. The data entry module 508 may be configured to receive input from one or more users of the hardware device 500 and to deliver such input to the processing unit 502 and/or the memory 504 via the bus 514.
A display 532 is also connected to the bus 514 via the display adapter 510. The display 532 may be configured to display output of the hardware device 500 to one or more users. In some embodiments, a given device such as a touch screen, for example, may function as both the data entry module 508 and the display 532. External display devices may also be connected to the bus 514 via an external display interface 534. Other peripheral output devices, not shown, such as speakers and printers, may be connected to the hardware device 500.
The hardware device 500 may operate in a networked environment using logical connections to one or more remote nodes (not shown) via the communication interface 512. The remote node may be another computer, a server, a router, a peer device or other common network node, and typically includes many or all of the elements described above relative to the hardware device 500. The communication interface 512 may interface with a wireless network and/or a wired network. Examples of wireless networks include, for example, a BLUETOOTH network, a wireless personal area network, a wireless 802.11 local area network (LAN), and/or wireless telephony network (e.g., a cellular, PCS, or GSM network). Examples of wired networks include, for example, a LAN, a fiber optic network, a wired personal area network, a telephony network, and/or a wide area network (WAN). Such networking environments are commonplace in intranets, the Internet, offices, enterprise-wide computer networks and the like. In some embodiments, the communication interface 512 may include logic configured to support direct memory access (DMA) transfers between the memory 504 and other devices.
In a networked environment, program modules depicted relative to the hardware device 500, or portions thereof, may be stored in a remote storage device, such as, for example, on a server. It will be appreciated that other hardware and/or software to establish a communications link between the hardware device 500 and other devices may be used.
It should be understood that the arrangement of the hardware device 500 illustrated in FIG. 5 is but one possible implementation and that other arrangements are possible. It should also be understood that the various system components (and means) defined by the claims, described below, and illustrated in the various block diagrams represent logical components that are configured to perform the functionality described herein. For example, one or more of these system components (and means) can be realized, in whole or in part, by at least some of the components illustrated in the arrangement of the hardware device 500. In addition, while at least one of these components are implemented at least partially as an electronic hardware component, and therefore constitutes a machine, the other components may be implemented in software, hardware, or a combination of software and hardware. More particularly, at least one component defined by the claims is implemented at least partially as an electronic hardware component, such as an instruction execution machine (e.g., a processor-based or processor-containing machine) and/or as specialized circuits or circuitry (e.g., discrete logic gates interconnected to perform a specialized function), such as those illustrated in FIG. 5. Other components may be implemented in software, hardware, or a combination of software and hardware. Moreover, some or all of these other components may be combined, some may be omitted altogether, and additional components can be added while still achieving the functionality described herein. Thus, the subject matter described herein can be embodied in many different variations, and all such variations are contemplated to be within the scope of what is claimed.
In the preceding description, the subject matter was described with reference to acts and symbolic representations of operations that are performed by one or more devices, unless indicated otherwise. As such, it will be understood that such acts and operations, which are at times referred to as being computer-executed, include the manipulation by the processing unit of data in a structured form. This manipulation transforms the data or maintains it at locations in the memory system of the computer, which reconfigures or otherwise alters the operation of the device in a manner well understood by those skilled in the art. The data structures where data is maintained are physical locations of the memory that have particular properties defined by the format of the data. However, while the subject matter is being described in the foregoing context, it is not meant to be limiting as those of skill in the art will appreciate that various of the acts and operations described hereinafter may also be implemented in hardware.
To facilitate an understanding of the subject matter described above, many aspects are described in terms of sequences of actions. At least one of these aspects defined by the claims is performed by an electronic hardware component. For example, it will be recognized that the various actions can be performed by specialized circuits or circuitry, by program instructions being executed by one or more processors, or by a combination of both. The description herein of any sequence of actions is not intended to imply that the specific order described for performing that sequence must be followed. All methods described herein can be performed in any suitable order unless otherwise indicated herein or otherwise clearly contradicted by context.
While one or more implementations have been described by way of example and in terms of the specific embodiments, it is to be understood that one or more implementations are not limited to the disclosed embodiments. To the contrary, it is intended to cover various modifications and similar arrangements as would be apparent to those skilled in the art. Therefore, the scope of the appended claims should be accorded the broadest interpretation so as to encompass all such modifications and similar arrangements.

## Claims

1. A system for recording file events in change logs while incrementally backing up file systems, the system comprising:
a processor-based application, which executed on a computer, will cause the processor to:
back up a file system incrementally by reading a current change log;
identify a file event associated with the file system, the file event occurring during the incremental back up of the file system;
identify a unique identifier associated with the identified file event;
determine whether the unique identifier associated with the file event is greater than a unique identifier associated with reading the current change log; and
record the file event in the current change log during the incremental backup of the file system in response to a determination that the unique identifier associated with the file event is greater than the unique identifier associated with reading the current change log.

2. The system of claim 1, wherein reading the current change log comprises reading the current change log in an order based on an increasing sequence of index node number offsets.

3. The system of claim 1, wherein the current change log records file events which occurred since a most recent back up of the file system.

4. The system of claim 1, wherein the file event comprises one of a file creation, a file modification, and a file deletion.

5. The system of claim 1, wherein the processor-based application, when executed, will further cause the processor to record the file event in a new change log in response to a determination that the unique identifier associated with the file event is not greater than the unique identifier associated with reading the current change log.

6. The system of claim 1, wherein the processor-based application, when executed, will further cause the processor to record subsequent file events to a new change log after incrementally backing up the file system is completed.

7. The system of claim 1, wherein the processor-based application, when executed, will further cause the processor to delete the current change log after incrementally backing up the file system is completed.

8. A computer-implemented method for recording file events in change logs while incrementally backing up file systems, the method comprising:
backing up a file system incrementally by reading a current change log;
identifying a file event associated with the file system, the file event occurring during the incremental back up of the file system;
identifying a unique identifier associated with the identified file event;
determining whether the unique identifier associated with the file event is greater than a unique identifier associated with reading the current change log; and
recording the file event in the current change log during the incremental backup of the file system in response to a determination that the unique identifier associated with the file event is greater than the unique identifier associated with reading the current change log.

9. The method of claim 8, wherein reading the current change log comprises reading the current change log in an order based on an increasing sequence of index node number offsets.

10. The method of claim 8, wherein the current change log records file events which occurred since a most recent back up of the file system.

11. The method of claim 8, wherein the file event comprises one of a file creation, a file modification, and a file deletion.

12. The method of claim 8, wherein the method further comprises recording the file event in a new change log in response to a determination that the unique identifier associated with the file event is not greater than the unique identifier associated with reading the current change log.

13. The method of claim 8, wherein the method further comprises recording subsequent file events to a new change log and deleting the current change log after incrementally backing up the file system is completed.

14. A computer program product, comprising a non-transitory computer-readable medium having a computer-readable program code embodied therein to be executed by one or more processors, the program code including instructions to:
back up a file system incrementally by reading a current change log;
identify a file event associated with the file system, the file event occurring during the incremental back up of the file system;
identify a unique identifier associated with the identified file event;
determine whether the unique identifier associated with the file event is greater than a unique identifier associated with reading the current change log; and
record the file event in the current change log during the incremental backup of the file system in response to a determination that the unique identifier associated with the file event is greater than the unique identifier associated with reading the current change log.

15. The computer program product of claim 14, wherein reading the current change log comprises reading the current change log in an order based on an increasing sequence of index node number offsets.

16. The computer program product of claim 14, wherein the current change log records file events which occurred since a most recent back up of the file system.

17. The computer program product of claim 14, wherein the file event comprises one of a file creation, a file modification, and a file deletion.

18. The computer program product of claim 14, wherein the program code includes further instructions to record the file event in a new change log in response to a determination that the unique identifier associated with the file event is not greater than the unique identifier associated with reading the current change log.

19. The computer program product of claim 14, wherein the program code includes further instructions to record subsequent file events to a new change log after incrementally backing up the file system is completed.

20. The computer program product of claim 14, wherein the program code includes further instructions to delete the current change log after incrementally backing up the file system is completed.