KR101237746B1 - Data backup apparatus and method for the same - Google Patents

Abstract

Disclosed are a data backup apparatus and method for finding a file whose data has changed and backing up the changed data.
In one embodiment, the apparatus and method for backing up data shortens the time required to back up data by incrementally backing up a file based on a file based on finding a changed file in a short time without navigating the entire directory tree, and the entire changed file. Instead, it finds only some changed records of the file and backs up only the changed part of the file without waste of using the storage media used for backup. Perform data backup so that data is not duplicated.

Description

DATA BACKUP APPARATUS AND METHOD FOR THE SAME}

Embodiments of the present invention relate to a data backup apparatus and method for finding a file whose data has changed and backing up the changed data.

Every application program stored in a computer's memory and executed by a processor operates to process data. In this case, the result data processed through the data operation of the application program is stored in the storage medium again by an input / output related system call. Data stored on storage media can be lost or lost due to various factors such as system failures, which can not only guarantee the continuity of work, but can also be expensive for data recovery.

In order to minimize the work gap resulting from data loss, the data management system has introduced a data backup system. The data backup system backs up the data using a method such as full backup and incremental backup depending on the importance and nature of the data. A full backup backs up all the data you want to back up. An incremental backup backs up only the data that has changed since the full backup. Incremental backups can save more time backing up because more data can be backed up than the full backup time.

When performing a full backup or incremental backup, there are two main methods of reading data: file-based and data-based blocks. Reading data on a block basis can reduce the time to read data by reading the entire disk at once and backing up the data. On the other hand, since backups are ignored while ignoring information on file or file system structure, it may take more time than file-based backups to handle requests such as recovering a part of a file in a specific file system. The method of backing up data based on files may take longer to read the data than the block based backup method, but since the information on the file system and files is completely backed up, it may be convenient and efficient to recover data.

A full backup uses all data as a backup target and reads the data to back up, so finding the backup target may not be an important factor in the overall backup time. However, finding a backup destination in an incremental backup is very important and can take a lot of time. For example, in order to incrementally back up data by reading data on a block basis, it is necessary to select data blocks that have changed since the full backup and provide a method of tracking which blocks have changed. In addition, incremental backup by reading data on a file basis requires knowing which files have changed since the full backup.

In general, in order to find a backup target file in a file-by-file backup, as illustrated in FIG. 1, the entire directory tree must be searched to check which file has changed since the previous backup. FIG. 1 illustrates a method of searching one of subdirectories of a root directory by a depth first search method. All directories should be checked in this way and compared with previous backup information to determine what has changed. Therefore, a backup of a file system containing a large number of files may take a long time in preparing a backup, although the data backup itself may take time.

One embodiment of the present invention provides a data backup apparatus and method for finding a file whose data has been changed in a short time and incrementally backing up the file without searching the entire directory tree.

In addition, an embodiment of the present invention provides a data backup apparatus and method for finding only a partial changed record of a file and backing up only the changed part of the file instead of the entire changed file.

In addition, an embodiment of the present invention provides a data backup apparatus and method for applying a deduplication method to a changed portion of a file to search and back up non-duplicate data.

In order to achieve the above object, a file backup device may input and output a file information about a backup target file processed by hooking the system call and being processed in association with the hooked system call as a system call occurs in an application program. Hooker; And a dispatcher for extracting the backup target file from a file pool using the generated file information and storing the backup target file in a backup storage.

In addition, as a technical method for achieving the above object, a file backup method, the system call in the application, the step of hooking the system call; Generating file information about a backup target file processed in association with the hooked system call; And extracting the backup target file from a file pool using the generated file information and storing the backup target file in a backup storage.

According to one embodiment of the present invention, the time required for data backup is shortened by finding the file whose data has been changed in a short time and incrementally backing up the file without searching the entire directory tree.

In addition, according to an embodiment of the present invention, the storage medium used for backup is used without waste by finding only a part of the changed record of the file and backing up only the changed part of the file instead of the entire changed file.

In addition, according to an embodiment of the present invention, by applying a deduplication method to the changed portion of the file to search for data that is not duplicated and backs up, the same data is not duplicated.

1 is an exemplary view illustrating an operation of searching one of subdirectories of a conventional root directory by a depth-first search method.
Figure 2 is an exemplary view showing a method of hooking a system call for explaining an embodiment of the present invention.
3 is an exemplary view showing a function execution flow with and without hooking for explaining an embodiment of the present invention.
4 is an exemplary view showing a system call hooking method using a loadable kernel module method for explaining an embodiment of the present invention.
5 is an exemplary view showing a basic configuration and a process for performing data backup for explaining an embodiment of the present invention.
6 is a block diagram showing the configuration and data flow of a data backup apparatus according to an embodiment of the present invention.
7 is an exemplary diagram illustrating an incremental backup target after full backup for explaining an embodiment of the present invention.
8 is a diagram illustrating an example of dividing a file into pieces of data to remove data duplication during file backup for explaining an embodiment of the present invention.

Hereinafter, embodiments according to the present invention will be described in detail with reference to the accompanying drawings. However, the present invention is not limited to or limited by the embodiments. Like reference symbols in the drawings denote like elements.

Every application program executed by a processor in a computer performs file input / output to process data. At this time, the result data processed through the execution of the application program is stored in the storage medium again by the input and output system call of the operating system. That is, the application program performs all operations related to a file such as creating a directory, creating a file, changing a file's contents, etc. by performing an input / output related system call provided by an operating system.

In file-based incremental backups, the backup processor tracks and records all changed or newly created files and directories, or operations related to files, to find the backup target file without traversing the entire directory tree. It is possible. This information can be tracked and extracted by hooking all I / O related system calls.

Figure 2 is an exemplary view showing a method of hooking a system call for explaining an embodiment of the present invention.

Write system call (write ()) to save data while the application is running If the system call command is called, the write system call is hooked by an input / output hooker of the data backup device, and a function hooked at the kernel level is called. The hooked function then acquires all the information needed to back up the data and returns to the flow of the original system call. Here, the write system call is a system call for storing the data of the variable size byte size stored in the variable buffer buf in the file indicated by the file descriptor fd.

The information needed to back up data in a write system call includes information about the file itself (file name including the absolute path of the file), the location and size of the file to be written, and the data itself to be written. Can be extracted. The information extracted for backup may vary slightly for each system call, but they can all be extracted in the same way. Therefore, by hooking up all system calls affecting the file system to obtain the information needed to back up data, you can efficiently back up without having to navigate the directory tree. In addition, this backup method can extract all the information about the files and data to be backed up without stopping the application from running, so the application does not recognize the existence of the backup software.

3 is an exemplary view showing a function execution flow with and without hooking for explaining an embodiment of the present invention.

Hooking refers to a program technique that uses a handler function to modify the execution flow of the original program. A new hook is registered as a function with the address for a particular function, and when that particular function is called, the hook is executed instead of that specific function. In this case, the hook generally calls the original function at a certain point in time to comply with the purpose of executing the original function.

4 is an exemplary view showing a system call hooking method using a loadable kernel module method for explaining an embodiment of the present invention.

A system call is an entry point for an application to request a service from the operating system kernel. By hooking these entry points, you can extend the services provided by the kernel of the original operating system. The way you hook system calls differs slightly by operating system. For example, we briefly describe the Loadable Kernel Module (LKM) method in the Linux operating system.

The LKM method is a method used to extend Linux kernel functionality. It creates a separate kernel module and dynamically loads and unloads the module into the Linux kernel without modifying or recompiling the existing kernel. The new device's driver or file system uses this approach a lot because of kernel modifications and the ability to load modules dynamically without recompilation.

When an application calls a system call, the hooked system call is executed while the hooked module is loaded. If the hooked module is not loaded, the original system call is executed. As described above, a hooked function always calls the function that should be executed at some point in time to comply with the purpose of executing the function.

5 is an exemplary view showing a basic configuration and a process for performing data backup for explaining an embodiment of the present invention.

In order to extract information required for data backup, two representative modules are needed in the kernel, and these modules are closely connected to the user-level backup processor 550 and executed.

When the application 510 calls an I / O related system call, the I / O hooker 520 extracts file information necessary for backup through the hooked system call. The original I / O related system call is continuously performed, and the extracted file information is stored in the list 540 by the collector 530 which is another module in the kernel. The backup processor 550 reads data to be backed up using the file information stored in the list 540 and stores the data to be backed up in the backup storage 560.

Here, the file information extracted by the input / output hooker 520 is classified into three categories as follows:

(1) information about files or directories (information for file-level incremental backups)

(2) Information on which part of the file has changed in size or how much data has been inserted or added to the information obtained in step (1) (information for incremental backup at record level).

(3) In addition to the information in (1) (2), the data itself written to the actual file (information for Continuous Data Protection)

6 is a block diagram showing the configuration and data flow of a data backup apparatus according to an embodiment of the present invention.

The I / O hooker 610 hooks I / O related system calls to information about a file or directory, and information about the creation or removal of a file or directory, information about a file to be changed (append, update, etc.), symbolic or hard. Extract the file or directory information associated with the link. The input / output hooker 610 stores the extracted information in the message queue 620 shared with the collector 630.

Here, files and directories are treated as files in the same way. In fact, Unix-like systems treat files and directories as files:

The file information extracted by the input / output hooker 610 and stored in the message queue 620 is stored in the list by the collector 630.

The kernel area input / output hooker 610 and the user area configuration manager 651 share directory information files 641 to exchange information with each other. That is, the directory related information that the user defines as the backup target is stored in the directory information file by the environment setting manager 651 of the user area, and the input / output hooker 610 uses the information stored in the directory information file 641 to back up the target. Extract information about files belonging to.

The backup processor 650 backs up data by scheduling a backup job according to a period desired by the user. When the data needs to be backed up, a dispatcher 652, a module of the user level backup processor 650, instructs the collector 630 to prepare for backup. The collector 630 receiving the backup command stores the file information stored in the message queue 620 as a list so as to inform the dispatcher 652 that the backup is ready. The collector 630 simultaneously generates another list and stores the file information extracted by the input / output hooker 610 in a newly created list separately and prepares for the next backup.

The dispatcher 652 organizes the backup target file 642 using the file information stored in the list by the collector 630, reads the backup target file 642, and stores the backup target file 642 in the backup storage 640. In this case, the dispatcher 652 does not need to search the directory tree of the files to find the backup target file 642. The backup target file 642 can be cleaned up using the file information already extracted by the input / output hooker 610, thereby improving the backup speed.

7 is an exemplary diagram illustrating an incremental backup target after full backup for explaining an embodiment of the present invention.

The backup processor backed up all files except file 6 in the full backup. Subsequently, it is assumed that file 6 is newly created until the backup processor incrementally backs up, and that data in different colors are changed in files 3 and 7. All of this file's change information is stored in a list generated by the collector. Therefore, if the backup processor performs file-level incremental backup by referring to the file information in the list generated by the collector, all incremental backups are performed by backing up all changed data of files 3, 6, and 7 without searching the backup target file. End the process.

If the backup processor can extract the information about the data in addition to the file-level incremental backup information, it can further reduce the backup time. In an embodiment of the present invention, this is called a record level backup, and in addition to the file level backup information described above, it is possible to extract the location and size information of the changed data in the file. In other words, the I / O hooker is in the following format (file name including absolute path, whether file is created / removed / linked / unlinked, file changed), the location of the changed data in the file, the size of the changed data, and so on. The information to be backed up is extracted and the backup processor backs up the data through the same process described above.

Record-level incremental backup is possible by adding data that is changed in the file as record-level information in addition to file information for file-level backup. That is, instead of backing up the entire changed file, the backup processor may read and back up only the changed data by using the location of the changed data and the size of the changed data. Thus, the backup processor not only saves time looking for backup targets, but also reduces the amount of data backed up rather than incremental backup at the file level, thereby reducing backup time and storage capacity for backups.

I / O hookers can implement CDP (Continuous Data Protection) by extracting the data that changes in addition to the information extracted for record-level data backup. That is, the I / O hooker can extract data that is changed correctly by hooking the write system call and extracting data stored in buf [size] which is a variable of the write system call. For the CDP, I / O hookers use the following (file names including absolute paths, file creation / removal / linking / unlinking, file changes, offsets within the file), changed data size, and Extract the file information to be backed up in the form of when the data was changed, and the backup processor refers to the file information extracted by the I / O hooker to back up the data:

Further information added to the record level backup information is the data itself and the time the data was changed. The process of backing up data is almost the same as the previous method, except that the data to be backed up is already extracted by the I / O hooker and the extracted data is stored in the list by the collector. Therefore, the backup processor does not need to read the data stored in the actual file and store the data in the backup storage. The data backup is completed by reading the data stored by the collector and storing the data in the backup storage. In this case, the information stored in the file may be stored in the backup storage on the basis of the time when the data is changed, and the backup processor may use the same to recover data of a desired time period.

8 is a diagram illustrating an example of dividing a file into pieces of data to remove data duplication during file backup for explaining an embodiment of the present invention.

With the development of the Internet, the amount of digital data produced and distributed every day is exploding. As a result, the demand for storage to store these data is exploding. However, it is also true that redundant data is a large part of such a large amount of digital data. For example, in the case of web storage, a large number of users upload and download files from each other, but files with different names or only partially changed files in the entire file are left indiscriminately. This redundant data wastes storage space on the storage.

Therefore, there is a need for a technology that can efficiently use storage by managing redundant data. For this purpose, data deduplication technology is being used. Data deduplication technology is particularly popular for data backup. In other words, by detecting duplicate data during data backup, the same data is prevented from being repeatedly stored in the backup storage to increase the use efficiency of the storage device.

The most obvious way to check for data redundancy is to compare bit by bit. However, this method can reliably check the data, but it is slow. One way to solve the speed problem is to compare the hash values of the files. The problem with this method is that when part of a file is changed or duplicates of a part of the file are not found. For this reason, the method of finding the internal duplication of a file is widely used by dividing the file into pieces and checking for duplicate data fragments. There are two ways to divide a file into fixed-length pieces of data and variable-length pieces of data.

 Fixed-size partitioning speeds up file splitting into pieces of data, but slows down finding duplicates of modified data. On the other hand, the variable length segmentation method also finds duplicates of data modified in the middle, so the probability of overlap detection is much higher than that of the fixed size segmentation method. On the other hand, the variable length partitioning method takes a long time to split a file into pieces of data.

The process by which the backup processor breaks up the file into pieces of data, deduplicates the data, and backs up the non-redundant data to backup storage.

The backup processor divides the file into chunks of data. The backup processor assigns unique index values to the fragmented data fragments and manages them separately for efficient retrieval.

The backup processor determines whether the data fragments overlap by comparing the index values of the divided data fragments.

If the backup processor determines that the data is duplicated, the dispatcher stores the information about the data fragment (location within the file, the size of the data fragment) and the data fragment along with the index in backup storage. Instead of storing data fragments in backup storage, only indexes are indicated through indexes.

The index value of the data fragment is usually 128 bits or more and is used to minimize the collision between the index values. Therefore, it can be seen that enabling the backup processor to efficiently manage and retrieve index values is an important factor affecting performance during data deduplication. Of course, the process of dividing a file into pieces of data can be time-consuming.

As a result, the most performance-neutral factors in data deduplication are the process of dividing files and managing and retrieving index values corresponding to pieces of data.

In the process of full backup, data deduplication must go through the process described above for all data files. However, if you go through the same steps in the incremental backup process, the time required for data deduplication will increase the total backup time.

Current data deduplication methods have a significant impact on backup time when a change is made to a part of a file, the whole file is divided into pieces of data, and the data pieces are checked for duplication. However, if you can break down the data into pieces that have changed and only check for redundancy, you can minimize the backup time while deduplicating the data.

This can be achieved using the record-level data backup method described above. FIG. 8A illustrates an example of dividing a file into n pieces of data for data deduplication during full backup. After the full backup, (b) of FIG. 8 means that data corresponding to data fragment n + 1 is written to the file. If you use the traditional data deduplication method, you can divide the file into pieces of data from the beginning, and check for duplication to make an incremental backup of the entire file.

On the other hand, using the record-level method described above, the backup processor can divide only the changed parts of the file into pieces of data, and only check whether the parts are duplicated, and back up only the parts that are not duplicated by the dispatcher. That is, in the record level backup, information on the location and size of the data to be changed can be already extracted through the input / output hooker. Therefore, the backup processor knows which data fragments are affected by the data that is being changed, divides it back into new data fragments only for the affected data fragments, checks for duplicates for newly created data fragments, and then duplicates them by the dispatcher. Only unspent pieces of data need to be stored in backup storage. For example, in FIG. 8 (b), the backup processor divides the newly added portion Ch n + 1 into pieces of data and performs redundancy check. If the data is changed as shown in FIG. 8 (c), the backup processor is changed. Divide the three data fragments (Ch1, Ch2, Ch3) affected by the data into new data fragments and back them up by checking for duplicates.

As a result, the backup processor only needs to create new pieces of data that are limited to the changed parts of the data, check for redundancy, and back up only those parts, thereby significantly reducing the time for splitting data and checking for duplicates. have.

Further, embodiments of the present invention include a computer readable medium having program instructions for performing various computer implemented operations. The computer readable medium may include program instructions, data files, data structures, etc. alone or in combination. The program instructions recorded on the medium may be those specially designed and constructed for the present invention or may be available to those skilled in the art of computer software. Examples of computer-readable recording media include magnetic media such as hard disks, floppy disks, and magnetic tape, optical media such as CD-ROMs, DVDs, and magnetic disks, such as floppy disks. Magneto-optical media, and hardware devices specifically configured to store and execute program instructions, such as ROM, RAM, flash memory, and the like. Examples of program instructions include not only machine code generated by a compiler, but also high-level language code that can be executed by a computer using an interpreter or the like.

In the present invention as described above has been described by the specific embodiments, such as specific components and limited embodiments and drawings, but this is provided to help a more general understanding of the present invention, the present invention is not limited to the above embodiments. For those skilled in the art, various modifications and variations are possible from these descriptions. Therefore, the spirit of the present invention should not be construed as being limited to the described embodiments, and all of the equivalents or equivalents of the claims, as well as the following claims, are included in the scope of the present invention.

510: Application
520: input and output hooker
530: Collector
540: list
550: Backup Processor
560: backup storage

Claims (15)

An input / output hooker for hooking the system call and generating file information about a backup target file processed in association with the hooked system call as a system call occurs in an application program; And
A dispatcher that extracts the backup target file from a file pool and stores the backup target file in a backup storage using the generated file information.
Including,
The input and output hooker,
Analyzing the system call to determine a file on which at least a part of the data has been subjected to the change processing as the backup target file, and generating file information including an identifier for identifying the determined backup target file. . The method of claim 1,
The file backup device,
Collector for creating a list containing the file information generated during the selected period
Further comprising:
The dispatcher,
A file backup device for extracting a file identified by file information in the list as the backup target file. The method of claim 2,
The collector,
And maintain the list in a message queue allocated corresponding to the period, and after the end of the period, remove the list maintained in the message queue. delete The method of claim 1,
The input and output hooker,
Analyzing the system call to generate file information including an identifier for identifying a location of the data on which the change processing is performed and size information of the data,
The dispatcher,
And a data corresponding to the size information from a position in the backup target file identified by the identifier, is extracted from the file pool and stored in backup storage. 6. The method according to claim 1 or 5,
The change process,
A file backup device that is a process relating to at least one of creation, removal, linking, or unlinking of data in a file. The method of claim 1,
The file information includes time information on which a change process on at least part of data in the backup target file is performed.
The dispatcher is,
In consideration of the time information, and determines the time to extract the backup target file to store in the backup storage. The method of claim 1,
The file backup device,
A configuration manager that receives a backup target file from a user and controls the input / output hooker to generate file information on the input backup target file.
Further comprising, a file backup device. The method of claim 1,
The file backup device,
A backup processor for dividing the backup target file into a plurality of data pieces and assigning an index to each of the divided data pieces
Further comprising a data backup device. 10. The method of claim 9,
The backup processor,
Among the plurality of data pieces, for the data pieces retrieved from the backup storage, the given indexes are replaced by redundant indexes.
The dispatcher is,
And storing the data fragments in the backup storage except for the data fragments to which the redundant index has been given. Hooking the system call as a system call occurs in an application;
Analyzing the system call in association with the hooked system call and determining a file to which a change process of at least some data has been performed as a backup target file;
Generating file information including an identifier for identifying the determined backup target file; And
Extracting the backup target file from a file pool using the generated file information and storing the backup target file in a backup storage;
Including, file backup method. delete The method of claim 11,
The file information includes an identifier for identifying a location of data on which change processing has been performed and size information of the data,
Extracting the backup target file and storing in the backup storage,
Extracting data corresponding to the size information from a location in the backup target file identified by the identifier from the file pool and storing the data in the backup storage;
Including, file backup method. The method of claim 11,
The file information includes time information on which a change process on at least part of data in the backup target file is performed.
Extracting the backup target file and storing in the backup storage,
Determining a time point at which the backup target file is extracted and stored in the backup storage in consideration of the time information;
Including, file backup method. The method of claim 11,
Dividing the backup target file into a plurality of pieces of data;
Assigning an index to each of the partitioned data fragments, wherein the indexes are replaced with redundant indexes for the data fragments retrieved from the backup storage among the plurality of data fragments; And
Storing the data fragments in the backup storage except for the data fragments to which the redundant index has been assigned.
Further comprising a data backup method.

Images