JP2015230504A - Snapshot control device, snapshot control method, and snapshot control program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To avoid becoming unable to write due to the shortage of free space in a data storage unit, etc., and copy a chunk appropriately.SOLUTION: When a request for write to a snapshot corresponding to file data which is stored in a plurality of data servers and which is stored separately in chunks of fixed length is accepted, a master server 100 determines a data server to which a chunk that is the object of the write request is copied by copy-on-write on the basis of one or more of a free space in the data storage unit of each data server, a distance between the data server holding the chunk to be copied and each data server, and the number of chunks shared by a plurality of files in each data server. Then, the master server 100 exerts control on the determined data server so that a chunk that is the object of the write request is copied.

Description

  The present invention relates to a snapshot control device, a snapshot control method, and a snapshot control program.

  In recent years, a distributed file system has been widely used. The distributed file system is composed of a large number of servers connected via a network, and realizes a huge storage device. Typically, a distributed file system is configured by connecting tens to hundreds or more servers across a plurality of racks via a network.

  Examples of such distributed file systems include Google (registered trademark) File System (hereinafter referred to as GFS, non-patent document 1) and Hadoop (registered trademark) Distributed File System (hereinafter referred to as HDFS, non-patent document 2). Are known. In these distributed file systems, a file is divided into fixed-length chunks and stored in each server (hereinafter referred to as a data server) constituting the distributed file system. In order to increase availability and fault tolerance, each chunk is duplicated and stored in a data server with a predetermined number of redundancy (3 by default in GFS and HDFS). Thereby, even if a failure occurs in a certain data server, the processing can be continued using the chunk stored in the other data server.

  GFS and HDFS provide a snapshot function. A snapshot is a copy of a file or directory tree at a certain point in time. Snapshots can be used for data backup and data recovery from incorrect operations.

  In GFS, it is possible to create a readable / writable snapshot for a file or directory. Copy-on-write is used to realize the snapshot, and high-speed snapshot creation and efficient storage use are possible.

  In HDFS, a read-only snapshot for a directory can be created. Since data is not copied when creating a snapshot, a snapshot can be created at high speed.

Sanjay Ghemawat, Howard Gobioff, Shun-Tak Leung, The Google File System, Proceedings of the 19th ACM Symposium on Operating Systems Principles, pages 29-43, October, 2003. Hadoop, [online], [Search May 9, 2014], Internet <http://hadoop.apache.org/>

  However, in the above-described GFS, when writing to a snapshot, the chunk is copied locally in the data server holding the chunk to be written by copy-on-write. However, there was a problem that the chunk copy could not be properly performed. In addition, in a data server that holds many files included in a snapshot, the number of chunks held by writing to the snapshot increases, and the load on the data server may increase.

  For example, the operation of creating a snapshot and writing to the snapshot in GFS is as follows. Here, as an example, assume that file 2 is created as a snapshot of file 1. When file 2 is created as a snapshot of file 1, file 1 and file 2 share the chunks that make up the file. Next, when writing to the file 2, the chunk is copied locally in the data server holding the chunk to be written by copy-on-write, and the file 2 is changed to refer to the copied chunk. . Here, the writing is performed on the copied chunk. Note that file 1 still refers to the original chunk. In addition, the chunk that is not a write target remains shared between the file 1 and the file 2.

  In copying a chunk by copy-on-write in GFS, the chunk is copied locally in the data server holding the chunk to be written. For this reason, if there is no free storage space, chunks cannot be copied locally within the data server. In addition, in a data server that holds many chunks shared by a plurality of files by snapshot, the number of chunks held by writing to the snapshot may increase, and the load on the data server may increase.

  The number of files and directories in which snapshots are created and the read / write load on snapshots vary depending on the use case. Therefore, it is necessary to control chunk copy by copy-on-write depending on the situation.

  In order to solve the above-described problems and achieve the object, the snapshot control device of the present invention is file data stored in a plurality of data servers, and is stored by dividing into fixed-length chunks. When a write request to a snapshot is received, the copy-destination data server to which the chunk that is the target of the write request is copied, the free space of the data storage unit in each data server, the chunk to be copied A determination unit that makes a determination based on one or more of the distance between each data server that is held, the load status of each data server, and the number of chunks shared by a plurality of files in each data server To the data server determined by the determination unit, the target of the write request. And a controlling unit for controlling to copy the link.

  The snapshot control method of the present invention is a snapshot control method executed by a snapshot control device, which is file data stored in a plurality of data servers, and is divided and stored in fixed-length chunks. When a write request to the snapshot for the file data that has been received is received, the copy-destination data server to which the chunk that is the target of the write request is copied, the free space of the data storage unit in each data server, the copy Based on one or more of the distance between each data server that holds the chunk to be processed, the load status of each data server, and the number of chunks shared by multiple files in each data server Determination process to determine, and data server determined by the determination process In contrast, characterized in that it includes a control step for controlling to copy the chunk to be the write request.

  In addition, the snapshot control program of the present invention receives file write requests for snapshots of file data stored in a plurality of data servers and stored divided into fixed-length chunks. , By copy-on-write, the copy destination data server of the chunk that is the target of the write request, the free capacity of the data storage unit in each data server, the data server holding the copied chunk and each data server A determination step based on any one or more of the distance, the load state of each data server, the number of chunks shared by a plurality of files in each data server, and the data server determined by the determination step On the other hand, the chunk that is the target of the write request is copied. Characterized in that to execute a control step of controlling to a computer.

  According to the present invention, even if the free space of the data storage unit of the data server holding the chunk shared by a plurality of files is insufficient, the chunk is transferred to another data server having the free space of the data storage unit. By copying, there is an effect that the chunk can be copied appropriately.

FIG. 1 is a diagram illustrating an example of a configuration of a snapshot control system according to the first embodiment. FIG. 2 is a diagram illustrating the relationship between file data and fixed-length chunks in the first embodiment. FIG. 3 is a diagram illustrating a relationship between a snapshot and a fixed-length chunk in the first embodiment. FIG. 4 is a diagram illustrating an example of the configuration of the master server in the first embodiment. FIG. 5 is a diagram illustrating an example of the configuration of the file table according to the first embodiment. FIG. 6 is a diagram illustrating an example of the configuration of the chunk table in the first embodiment. FIG. 7 is a diagram illustrating an example of the configuration of the data server state management table in the first embodiment. FIG. 8 is a diagram illustrating an example of the configuration of the data server according to the first embodiment. FIG. 9 is a diagram illustrating an example of the configuration of the chunk information table according to the first embodiment. FIG. 10 is a flowchart illustrating an example of an operation when an external application transmits a file generation request to the master server in the file generation process according to the first embodiment. FIG. 11 is a flowchart illustrating an example of an operation when the master server receives a file generation request from an external application in the file generation process according to the first embodiment. FIG. 12 is a flowchart illustrating an example of an operation when an external application transmits a directory generation request to the master server in the directory generation processing according to the first embodiment. FIG. 13 is a flowchart illustrating an example of an operation when the master server receives a directory generation request from an external application in the directory generation processing according to the first embodiment. FIG. 14 is a flowchart illustrating an example of an operation when an external application transmits a snapshot generation request to the master server in the snapshot generation processing according to the first embodiment. FIG. 15 is a flowchart illustrating an example of an operation when the master server receives a snapshot generation request from an external application in the snapshot generation processing according to the first embodiment. FIG. 16 is a flowchart illustrating an example of an operation when the master server receives a snapshot generation request from an external application in the snapshot generation processing according to the first embodiment. FIG. 17 is a flowchart illustrating an example of an operation when the master server receives a snapshot generation request from an external application in the snapshot generation processing according to the first embodiment. FIG. 18 is a flowchart illustrating an example of an operation when an external application writes to a file in the writing process according to the first embodiment. FIG. 19 is a flowchart illustrating an example of an operation when the master server receives a chunk information acquisition request in the writing process according to the first embodiment. FIG. 20 is a flowchart illustrating an example of an operation when the master server receives a chunk information acquisition request in the writing process according to the first embodiment. FIG. 21 is a flowchart illustrating an example of an operation when the master server receives a chunk information acquisition request in the writing process according to the first embodiment. FIG. 22 is a flowchart illustrating an example of an operation when the master server receives a chunk information acquisition request in the writing process according to the first embodiment. FIG. 23 is a flowchart illustrating an example of an operation when the data server receives a local chunk copy request from the master server in the writing process according to the first embodiment. FIG. 24 is a flowchart illustrating an example of an operation when the data server receives a remote chunk copy request from the master server in the writing process according to the first embodiment. FIG. 25 is a flowchart illustrating an example of an operation when the data server receives a chunk read request from another data server in the writing process according to the first embodiment. FIG. 26 is a flowchart illustrating an example of an operation when the data server receives a chunk generation request from the master server in the writing process according to the first embodiment. FIG. 27 is a flowchart illustrating an example of an operation when the data server receives a write control delegation request from the master server in the write processing according to the first embodiment. FIG. 28 is a flowchart illustrating an example of an operation when the data server receives a data transmission request from an external application or another data server in the writing process according to the first embodiment. FIG. 29 is a flowchart illustrating an example of an operation when the primary data server receives a write request from an external application in the write processing according to the first embodiment. FIG. 30 is a flowchart illustrating an example of an operation when the secondary data server receives a secondary write request from the primary data server in the write processing according to the first embodiment. FIG. 31 is a diagram illustrating a computer that executes a snapshot control program.

  Exemplary embodiments of a snapshot control device, a snapshot control method, and a snapshot control program according to the present invention will be explained below in detail with reference to the accompanying drawings. In addition, this invention is not limited by this embodiment.

[Example of Configuration of Snapshot Control System in First Embodiment]
FIG. 1 is a diagram illustrating an example of a configuration of a snapshot control system according to the first embodiment.

  As shown in FIG. 1, the snapshot control system in the first embodiment is configured as a master server 100 and a plurality of data servers 200, 300, 400, 500, 600. The master server 100 and the data servers 200, 300, 400, 500, 600 are connected via a network 800. The master server 100 is a snapshot control device that holds metadata for managing the name space of the distributed file system, allocation of chunks to the data server, and the like. The data servers 200, 300, 400, 500, and 600 are storage devices that hold chunks. The external application 700 requests creation and deletion of files and directories, creation and deletion of snapshots, reading and writing of files, and the like. In FIG. 1, one master server is shown as an example. However, in order to increase availability and fault tolerance, a plurality of master servers may be prepared and metadata may be synchronized between the master servers. In FIG. 1, five data servers are shown as an example, but the number of data servers is not limited to five.

  The data server 200, 300, 400, 500, 600 is assigned a data server identifier for uniquely identifying each data server. For example, an IP address assigned to a network interface of a computer on which the data servers 200, 300, 400, 500, and 600 operate is used as the data server identifier. In the example of FIG. 1, data server identifiers ds2, ds3, ds4, ds5, and ds6 are assigned to the data servers 200, 300, 400, 500, and 600, respectively.

  File data written by the external application 700 is divided into fixed-length chunks and stored in the data server. Each chunk is assigned a chunk identifier for uniquely identifying the chunk. Each chunk is stored in a predetermined number of data servers.

  FIG. 2 is a diagram illustrating the relationship between file data and fixed-length chunks in the first embodiment. In the example of FIG. 2, the file data 900 is divided into fixed-length chunks 910, 920, and 930. Chunk identifiers c1, c2, and c3 are assigned to the chunks 910, 920, and 930, respectively. When the file size is not a multiple of the fixed length, the size of the trailing chunk 930 is smaller than the fixed length. In addition, when there is a section in which no data exists in the file, the chunk may be smaller than the fixed length or may be a section to which no chunk is allocated.

  FIG. 3 is a diagram illustrating a relationship between a snapshot and a fixed-length chunk in the first embodiment. FIG. 3A shows the state of the file 1 1000 before creating the snapshot. The file 1 1000 includes chunks 1010, 1020, and 1030 identified by chunk identifiers c1, c2, and c3. FIG. 3B shows the state of the file 1 1000 and the file 2 1100 when the file 2 1100 is created as a snapshot of the file 1 1000. File 1 1000 and file 2 1100 share chunks 1010, 1020, 1030 identified by chunk identifiers c1, c2, c3.

  FIG. 3 (3) shows the state of file 1 1000 and file 2 1100 after writing to the end of file 2 1100. When writing to the file 2 1100 is performed, the chunk 1030 identified by the chunk identifier c3 that is the write target chunk is copied, and the chunk 1130 identified by the chunk identifier c4 is generated. File 2 1100 is modified to refer to chunk 1130 identified by chunk identifier c4. The writing is performed on the chunk 1130 identified by the chunk identifier c4. File 1 1000 remains referenced to chunk 1030 identified by chunk identifier c3. Also, the chunk 1010 identified by the chunk identifier c1 and the chunk 1020 identified by the chunk identifier c2 remain shared by the file 1 1000 and the file 2 1100.

[One Example of Configuration of Master Server 100 in the First Embodiment]
FIG. 4 is a diagram illustrating an example of the configuration of the master server 100 according to the first embodiment. The master server 100 includes a file management unit 110 and a data server state management unit 120. The file management unit 110 manages the creation and deletion of files and directories, the allocation of chunks to files, and the allocation of data servers that hold chunks. The file management unit 110 holds a file table 111 for associating a file with chunks constituting the file. In addition, the file management unit 110 holds a chunk table 112 for associating the chunk with a data server that holds the chunk. In addition, the file management unit 110 includes a determination unit 113 and a control unit 114.

  When the determination unit 113 accepts a write request to a snapshot for file data stored in a plurality of data servers and stored by dividing into fixed-length chunks, by copy-on-write, The data server that is the copy destination of the chunk that is the target of the write request, the free space of the data storage unit in each data server, the distance between the data server holding the copied chunk and each data server, This is determined based on one or more of the load status and the number of chunks shared by a plurality of files in each data server.

  For example, the determination unit 113 selects the data server having the lowest load state acquired by the data server state management unit 120 described later from among the data servers in which the free space of the data storage unit in the data server is equal to or greater than a predetermined threshold. Determine as the data server of the copy destination.

  In addition, the determination unit 113 is, for example, the data server having the smallest distance from the data server that holds the chunk to be copied from among the data servers in which the free space of the data storage unit in the data server is equal to or greater than a predetermined threshold Is determined as the data server of the copy destination.

  In addition, the determination unit 113 determines, for example, that the number of chunks shared by a plurality of files in each data server from a data server in which the free space of the data storage unit in the data server is equal to or greater than a predetermined threshold. One of the data servers that is less than the number is determined as a copy destination data server.

  Here, the “distance” with the data server holding the chunk to be copied from the data servers in which the free space of the data storage unit in the data server is equal to or greater than a predetermined threshold, and the “load state” of each data server It is assumed that the administrator can arbitrarily select which parameter of the “number of chunks” shared by a plurality of files in each data server to determine the copy destination data server. For example, if the snapshot control system is such that the data servers are separated from each other on the network, copy the data server with the smallest “distance” from the data server holding the copied chunk. It is preferable to set so as to be determined as the previous data server. Thus, parameters can be arbitrarily selected according to the characteristics of the snapshot control system.

  It is also possible to set a plurality of parameters, and it is also possible to select a plurality of parameters and set the priority order for the parameters. For example, the “load state” of each data server is set to the highest priority, and the “number of chunks” shared by a plurality of files in each data server is set to the second highest priority. In such a case, for example, when there are a plurality of data servers having the lowest load state, the data in which the number of chunks shared by the plurality of files is less than a predetermined threshold from among the data servers. You may make it determine a server as a data server of a copy destination.

  In addition, the control unit 114 controls the data server determined by the determination unit 113 to copy the chunk that is the target of the write request.

  The data server state management unit 120 manages the state of the data server. The data server state management unit 120 holds a data server state management table 121 that holds information related to the state of the data server. The data server status management unit 120 acquires the maximum data capacity that can be stored in the data storage unit of each data server, the free capacity of the data storage unit, and the load status of the data server from all the data servers. The data storage unit of the data server will be described later.

  The file table 111 holds, for each file or directory, a path name of the file or directory, a path type indicating whether the file or directory, and a chunk identifier list that is a list of chunk identifiers of each chunk constituting the file. To do. In addition to these, the file table 111 may hold other information related to files or directories.

  FIG. 5 is a diagram illustrating an example of the configuration of the file table 111 according to the first embodiment. In the example of FIG. 5, a directory “/”, a file “/ file1”, a file “/ file2”, and a file “/ file3” are registered in the file table 111 as path names. In the path type, “f” represents a file and “d” represents a directory. Since the directory in the first embodiment does not have information regarding files and directories in the directory, the chunk identifier list in the directory is not used. In the example of FIG. 5, the unused chunk identifier list of the directory “/” is represented by “−”. The file “/ file1” is composed of chunks identified by chunk identifiers c1, c2, and c3. The file “/ file2” is created as a snapshot of the file “/ file1” and then written to the end of the file, and is composed of chunks identified by chunk identifiers c1, c2, and c4. The file “/ file3” is composed of chunks identified by the chunk identifier c5.

  The chunk table 112 is a list of chunk identifiers of each chunk, a reference count indicating the number of files sharing the chunk, and a data server identifier of each data server that stores the chunk. Holds a data server identifier list.

  FIG. 6 is a diagram illustrating an example of the configuration of the chunk table 112 according to the first embodiment. In the example of FIG. 6, the chunk identified by the chunk identifier c1 has a reference count of 2, and is stored in each data server identified by the data server identifiers ds2, ds3, and ds4. The chunk identified by the chunk identifier c2 has a reference count of 2, and is stored in each of the data servers identified by the data server identifiers ds2, ds5, and ds6. The chunk identified by the chunk identifier c3 has a reference count of 1, and is stored in each of the data servers identified by the data server identifiers ds2, ds4, and ds5. The chunk identified by the chunk identifier c4 has a reference count of 1, and is stored in each of the data servers identified by the data server identifiers ds2, ds4, and ds6. The chunk identified by the chunk identifier c5 has a reference count of 1, and is stored in each of the data servers identified by the data server identifiers ds3, ds4, and ds5.

  In the example of FIG. 6, since the chunk identified by the chunk identifier c1 and the chunk identified by the chunk identifier c2 are shared by the file “/ file1” and the file “/ file2”, the reference count becomes 2, respectively. ing. Further, when writing to the end of the file “/ file2”, the chunk identified by the chunk identifier c3 is copied to the chunk identified by the chunk identifier c4 by copy-on-write, and then identified by the chunk identifier c4. The chunk is being written to. In the data server identified by the data server identifier ds2 and the data server identified by the data server identifier ds4, the copy of the chunk by copy-on-write is performed locally within the same data server, but the data server identifier ds5 In the identified data server, the chunk is copied to the data server identified by the data server identifier ds6.

  The data server state management table 121 includes, for each data server, the data server identifier of the data server, the maximum capacity of data that can be stored in the data storage unit of the data server, the free capacity of the data storage unit, and the data Maintains server load status. In addition to these, the data server state management table 121 may hold other information related to the data server.

  FIG. 7 is a diagram illustrating an example of the configuration of the data server state management table 121 according to the first embodiment. In the example of FIG. 7, the maximum capacity of data that can be stored in the data storage unit of the data server 200 identified by the data server identifier ds2 is 2.0 terabytes (TB), the free capacity is 1.0 terabytes (TB), and the load The state is 0.5, the maximum capacity of data that can be stored in the data storage unit of the data server 300 identified by the data server identifier ds3 is 2.0 terabytes (TB), the free capacity is 1.1 terabytes (TB), and the load The state is 1.0, the maximum capacity of data that can be stored in the data storage unit of the data server 400 identified by the data server identifier ds4 is 1.0 terabyte (TB), the free capacity is 0.6 terabyte (TB), and the load The state is 3.0, and the maximum capacity of data that can be stored in the data storage unit of the data server 500 identified by the data server identifier ds5 is 1.0 terabyte (T ), The free capacity is 0.1 terabytes (TB), the load state is 0.8, and the maximum capacity of data that can be stored in the data storage unit of the data server 600 identified by the data server identifier ds6 is 1.5 terabytes (TB) ), The free space is 0.7 terabytes (TB), and the load state is 0.5.

  As described above, the master server 100 determines a copy destination of a chunk by copy-on-write based on various copy-on-write strategies in copying a chunk by copy-on-write. For this reason, even if the free space of the data storage unit of the data server that holds chunks shared by multiple files is insufficient, the chunk is copied to another data server that has free space in the data storage unit. Thus, it is possible to continue writing or to distribute the load among the data servers.

[One example of configuration of data server in first embodiment]
FIG. 8 is a diagram illustrating an example of the configuration of the data servers 200, 300, 400, 500, and 600 according to the first embodiment. The configurations of the data servers 200, 300, 400, 500, and 600 are all the same, and the data server 200 will be described below as a representative example. In the following description, reference numerals of constituent elements of other corresponding data servers 300, 400, 500, and 600 are shown together with parentheses as necessary.

  The data server 200 (300, 400, 500, 600) includes a data storage unit 210 (310, 410, 510, 610), a data access unit 220 (320, 420, 520, 620), and a status notification unit 230 (330, 430, 530, 630).

  The data storage unit 210 (310, 410, 510, 610) holds all the chunks stored in the data server 200 (300, 400, 500, 600) and the chunk information table 211 (311, 411, 511, 611). .

  The chunk information table 211 (311, 411, 511, 611) in the first embodiment, for each chunk to be stored, the chunk identifier of the chunk and the data storage unit 210 (310, 410, 510, 610) The storage location of the chunk and the size of the chunk are stored. In addition to these, the chunk information table 211 (311 411 511 611) may hold other information related to the chunk.

  FIG. 9 is a diagram illustrating an example of the configuration of the chunk information table 211 (311 411 511 611) according to the first embodiment. In the example of FIG. 9, the chunk identified by the chunk identifier c1 is stored at the position identified by “p1” in the data storage unit 210, the chunk size is 64 megabytes (MB), and the chunk identifier c2 The identified chunk is stored in the position identified by “p2” in the data storage unit 210, the chunk size is 64 megabytes (MB), and the chunk identified by the chunk identifier c3 is stored in the data storage unit 210. The chunk size is 48 megabytes (MB), and the chunk identified by the chunk identifier c4 is the position identified by “p4” in the data storage unit 210. The chunk size is 64 megabytes (MB).

  The data access unit 220 (320, 420, 520, 620) executes reading and writing of chunks stored in the data storage unit 210 (310, 410, 510, 610). Further, the data access unit 220 (320, 420, 520, 620) stores information in the chunk information table 211 (311, 411, 511, 611) stored in the data storage unit 210 (310, 410, 510, 610). Read and write are executed.

  The state notification unit 230 (330, 430, 530, 630) monitors the state of the data storage unit 210 (310, 410, 510, 610) and the load state of the data server 200 (300, 400, 500, 600), Notify the master server 100. The status notification unit 230 (330, 430, 530, 630) includes a maximum capacity of data that can be stored in the data storage unit 210 (310, 410, 510, 610) and the data storage unit 210 (310, 410, 510, 610). And the data server 200 (300, 400, 500, 600) are periodically detected, and the detected maximum capacity, free capacity, and load status are notified to the master server 100.

  The master server 100 updates the maximum capacity, free capacity, and load state of the data server in the data server state management table 121 of the data server state management unit 120 with the notified maximum capacity, free capacity, and load state. In addition to these, the state notification unit 230 (330, 430, 530, 630) may notify the master server 100 of other information related to the data server 200 (300, 400, 500, 600). Here, the state is periodically detected and notified, but detection and notification may be executed in response to the occurrence of some event.

[One example of snapshot control in the first embodiment]
First, an example of processing when generating a file or directory will be described in [Example of file generation processing] and [Example of directory generation processing]. Next, an example of processing when generating a snapshot of a file or directory will be described in [Example of snapshot generation processing]. Finally, an example of a file writing process will be described in [Example of writing process].

[Example of file generation processing]
[Example of processing of external application 700 in file generation processing]
FIG. 10 is a flowchart illustrating an example of an operation when the external application 700 transmits a file generation request to the master server 100 in the file generation process according to the first embodiment.

  The external application 700 transmits a file generation request and a file path name to the master server 100 (step S1001). Then, the external application 700 receives a file generation response from the master server 100 (step S1002).

[Example of processing of master server 100 in file generation processing]
FIG. 11 is a flowchart illustrating an example of an operation when the master server 100 receives a file generation request from the external application 700 in the file generation process according to the first embodiment.

  The master server 100 receives a file generation request and a file path name from the external application 700 (step S1101). Then, the master server 100 registers the file path name, the path type “f” indicating that the file is a file, and an empty chunk identifier list in the file table 111 of the file management unit 110 (step S1102). Subsequently, the master server 100 transmits a file generation response to the external application 700 (step S1103).

[Example of directory generation processing]
[Example of processing of external application 700 in directory generation processing]
FIG. 12 is a flowchart illustrating an example of an operation when the external application 700 transmits a directory generation request to the master server 100 in the directory generation process according to the first embodiment.

  The external application 700 transmits a directory generation request and a directory path name to the master server 100 (step S1201). Then, the external application 700 receives a directory generation response from the master server 100 (step S1202).

[Example of processing of master server 100 in directory generation processing]
FIG. 13 is a flowchart illustrating an example of an operation when the master server 100 receives a directory generation request from the external application 700 in the directory generation process according to the first embodiment.

  The master server 100 receives a directory generation request and a directory path name from the external application 700 (step S1301). Then, the master server 100 registers the directory path name and the path type “d” indicating the directory in the file table 111 of the file management unit 110 (step S1302). Chunk identifier list is not used. Subsequently, the master server 100 transmits a directory generation response to the external application 700 (step S1303).

[Example of snapshot generation processing]
[Example of processing of external application 700 in snapshot generation processing]
FIG. 14 is a flowchart illustrating an example of an operation when the external application 700 transmits a snapshot generation request to the master server 100 in the snapshot generation processing according to the first embodiment.

  The external application 700 transmits a snapshot generation request, a snapshot source path name, and a snapshot destination path name to the master server 100 (step S1401). Then, the external application 700 receives a snapshot generation response from the master server 100 (step S1402).

[Example of processing of master server 100 in snapshot generation processing]
FIG. 15 is a flowchart illustrating an example of an operation when the master server 100 receives a snapshot generation request from the external application 700 in the snapshot generation processing according to the first embodiment.

  The master server 100 receives a snapshot generation request, a snapshot source path name, and a snapshot destination path name from the external application 700 (step S1501).

  Then, the master server 100 acquires a path type for the snapshot source path name in the file table 111 of the file management unit 110 and a chunk identifier list (step S1502).

  Subsequently, the master server 100 proceeds to step S1504 if the path type is “f”, and proceeds to step S1505 if the path type is “d” (step S1503). If the path type is “f”, the master server 100 executes file snapshot processing (step S1504-1 to step S1504-5) (step S1504).

  Here, the file snapshot processing of the master server 100 will be described with reference to FIG. The master server 100 registers the snapshot destination path name, the path type “f”, and the chunk identifier list acquired in step S1502 in the file table 111 of the file management unit 110 (step S1504-1). Here, the master server 100 executes the process of step S1504-4 described later for all chunk identifiers in the chunk identifier list.

  First, an index indicating the position of the chunk identifier in the chunk identifier list is set at the head in the chunk identifier list (step S1504-2).

  Subsequently, the master server 100 determines whether or not the processing of all chunk identifiers in the chunk identifier list has been completed (step S1504-3). Otherwise, the process proceeds to step S1504-4.

  If the processing of all chunk identifiers in the chunk identifier list is not completed, the master server 100 sets the reference count value for the chunk identifier at the index position in the chunk identifier list in the chunk table 112 of the file management unit 110. It is increased by 1 (step S1504-4). Thereafter, the master server 100 sets the index to the next position in the chunk identifier list (step S1504-5).

  Returning to the description of FIG. 15, if the path type is “d”, the master server 100 executes directory snapshot processing (step S1505-1 to step S1505-11) (step S1505). In directory snapshot processing, snapshots are recursively created for files and directories under the directory.

  Here, the directory snapshot processing of the master server 100 will be described with reference to FIG. The master server 100 acquires a list of all path names under the snapshot source path name (hereinafter referred to as snapshot source subordinate path name list) from the file table 111 of the file management unit 110 (step S1505-1).

  The master server 100 executes the processing from step S1505-4 to step S1505-10 for all the path names in the snapshot source subordinate path name list. First, the index 1 indicating the position of the path name in the snapshot source subordinate path name list is set to the head in the snapshot source subordinate path name list (step S1505-2).

  Then, the master server 100 determines whether or not the processing of all path names in the snapshot source subordinate path name list is completed (step S1505-3). If it is determined that the process has not been completed, the process proceeds to step S1505-4.

  If the processing of all path names in the snapshot source subordinate path name list is not completed, the master server 100 positions index 1 in the snapshot source subordinate path name list in the file table 111 of the file management unit 110. A path type and a chunk identifier list for the path name are acquired (step S1505-4).

  Subsequently, the master server 100 stores the portion from the root directory to the parent directory in the path name at the index 1 position in the snapshot source subordinate path name list in the file table 111 of the file management unit 110 as the snapshot destination path name. The replaced path name, the path type acquired in step S1505-4, and the chunk identifier list acquired in step S1505-4 are registered (step S1505-5).

  Then, the master server 100 determines whether the path type is “f” or “d”. If “f”, the process proceeds to step S1505-7, and if “d”, the process proceeds to step S1505-11. (Step S1505-6). Here, when the path type is “f”, the master server 100 executes the process of step S1505-9 described later for all chunk identifiers in the chunk identifier list.

  First, index 2 indicating the position of the chunk identifier in the chunk identifier list is set at the head of the chunk identifier list (step S1505-7).

  The master server 100 proceeds to step S1505-11 when processing of all chunk identifiers in the chunk identifier list is completed, and proceeds to step S1505-9 otherwise (step S1505-8).

  If the master server 100 has not processed all the chunk identifiers in the chunk identifier list, the value of the reference count for the chunk identifier at the position of index 2 in the chunk identifier list in the chunk table 112 of the file management unit 110. Is increased by 1 (step S1505-9).

  Then, the master server 100 sets the index 2 to the next position in the chunk identifier list (step S1505-10). When the master server 100 completes the processing of all the chunk identifiers in the chunk identifier list, the master server 100 sets the index 1 to the next position in the snapshot source subordinate path name list (step S1505-11).

  Returning to the description of FIG. 15, in step S1506, the master server 100 transmits a snapshot generation response to the external application 700 (step S1506).

[Example of writing process]
[Example of Processing of External Application 700 in Write Processing]
FIG. 18 is a flowchart illustrating an example of an operation when the external application 700 writes to a file in the writing process according to the first embodiment.

  The external application 700 transmits a chunk information acquisition request, a file path name, and a writing position (offset from the beginning of the file) to the master server 100 (step S1601).

  Then, the external application 700 sends a chunk server identifier (hereinafter referred to as a write target chunk identifier) corresponding to the write position from the master server 100 and a data server (hereinafter referred to as a write target) that holds the chunk identified by the write target chunk identifier. A list of data server identifiers of the chunk holding data server (hereinafter referred to as a write target chunk holding data server identifier list) is received (step S1602).

  Subsequently, the external application 700 selects a data server closest to the data server identified by the data server identifier in the write target chunk holding data server identifier list, and sends a data transmission request to the selected data server and the write The target chunk identifier, write data, and the write target chunk holding data server identifier list are transmitted (step S1603).

  The data server that has received the data transmission request transmits the data transmission request to the data server having the shortest distance among the write target chunk holding data servers that have not yet received the data transmission request. Thereafter, the transmission of the data transmission request is repeated until all the write target chunk holding data servers receive the data transmission request. The operation when the data server receives the data transmission request will be described later.

  As an example of the distance between two data servers, a value obtained by adding 1 to the natural logarithm of the exclusive OR of the IP addresses assigned to the network interface of the computer on which the two data servers are operating. In this example, the distance increases as the upper bits of the two IP addresses differ. Here, as an example, it is assumed that the data server 200 is selected as the closest data server.

  Then, the external application 700 receives a data transmission response from the data server 200 (step S1604). Subsequently, the external application 700 transmits a write request, the write target chunk identifier, and the write position to the primary data server (step S1605).

  The primary data server is a data server to which control related to writing to the chunk is delegated from the master server 100, and the master server is selected from the data servers identified by the data server identifier in the chunk storage data server identifier list to be written. 100 selects. Moreover, data servers other than the primary data server among the data servers identified by the data server identifier in the write target chunk holding data server identifier list are set as secondary data servers. A method for selecting the primary data server will be described later. Here, as an example, it is assumed that the data server 400 is selected as the primary data server. Then, the external application 700 receives a write response from the data server 400 (step S1606).

[Example of processing of master server 100 in write processing]
FIG. 19 is a flowchart illustrating an example of an operation when the master server 100 receives a chunk information acquisition request from the external application 700 in the writing process according to the first embodiment.

  The master server 100 receives a chunk information acquisition request, a file path name, and a writing position from the external application 700 (step S1701). Then, the master server 100 acquires a chunk identifier list for the file path name from the file table 111 of the file management unit 110 (step S1702).

  If there is a chunk identifier corresponding to the write position (hereinafter, write position chunk identifier) in the chunk identifier list, the master server 100 proceeds to step S1704; otherwise, the master server 100 proceeds to step S1707 (step S1703). In writing that causes copy-on-write, since the writing position chunk identifier exists, the process proceeds to step S1704.

  If the reference count for the write position chunk identifier in the chunk table 112 of the file management unit 110 is 2 or more, the master server 100 proceeds to step S1705; otherwise, the master server 100 proceeds to step S1706 (step S1704).

  In writing that causes copy-on-write, the chunk identified by the writing position chunk identifier is shared by a plurality of files, and the reference count for the writing position chunk identifier is 2 or more, so the process proceeds to step S1705. become. The master server 100 executes a copy-on-write process (steps S1705-1 to S1705-13) (step S1705).

  Here, the copy-on-write process will be described with reference to FIG. The master server 100 acquires a data server identifier list (hereinafter, copy target chunk holding data server identifier list) for the write position chunk identifier from the chunk table 112 of the file management unit 110 (step S1705-1). Here, as an example, it is assumed that ds2, ds4, and ds5 are acquired as the copy target chunk holding data server identifier list.

  Then, the master server 100 generates a new chunk identifier (hereinafter, write target chunk identifier) and an empty data server identifier list (hereinafter, write target chunk holding data server identifier list) (step S1705-2).

  The master server 100 executes the processing from step S1705-5 to step S1705-11 for all data server identifiers in the copy target chunk holding data server identifier list (hereinafter, copy target chunk holding data server identifier). First, an index indicating the position of the copy target chunk holding data server identifier in the copy target chunk holding data server identifier list is set to the head in the copy target chunk holding data server identifier list (step S1705-3).

  The master server 100 proceeds to step S1705-13 when processing of all the copy target chunk holding data server identifiers in the copy target chunk holding data server identifier list is completed, and to step S1705-5 otherwise (step S1705-5). S1705-4).

  If processing of all copy target chunk holding data server identifiers in the copy target chunk holding data server identifier list has not been completed, the master server 100 copies at the index position in the copying target chunk holding data server identifier list. Based on the copy-on-write strategy for the target chunk holding data server identifier, the data server holding the chunk to be copied (hereinafter, write target chunk holding data server) is determined (step S1705-5).

  As an example of a copy-on-write strategy, if the free space of the data storage unit of the data server identified by the copy target chunk holding data server identifier is equal to or greater than a predetermined threshold, the data server itself is selected as the writing target chunk holding data server Otherwise, the free space in the data storage unit, except for the data server operating on the computer stored in the same rack as the computer on which the data server already selected as the write target chunk holding data server operates Among the data servers that are equal to or greater than a predetermined threshold, the data server having the smallest distance between each data server identified by the copy target chunk holding data server identifier in the copy target chunk holding data server identifier list, The data server with the lowest load, Of the chunk held, the value of the reference count is selected as the target chunk held data server writes data servers less than the threshold number has been determined of 2 or more chunks. In addition, the free space of the data storage unit in each data server, the distance between the data server holding the chunk to be copied and each data server, the load state of each data server, shared by a plurality of files in each data server It can also be selected based on any one or more of the number of chunks present.

  Here, in order to obtain at high speed the number of chunks having a reference count value of 2 or more for each data server, the master server 100 sends the data server identifier of the data server and the data server to each data server. You may hold | maintain the table holding the value of the reference count in the data server identified by an identifier with the number of chunks 2 or more.

  Even if the distributed file system prepares one or more copy-on-write strategies in advance and the user selects a copy-on-write strategy to use from them, or the user defines and uses his own copy-on-write strategy Good.

  Here, as an example, when the copy target chunk holding data server identifier is ds2, the data server 200 identified by the data server identifier ds2 as the write target chunk holding data server, and when the copy target chunk holding data server identifier is ds4, The data server 400 identified by the data server identifier ds4 as the write target chunk holding data server, and the data server 600 identified by the data server identifier ds6 as the writing target chunk holding data server when the copy target chunk holding data server identifier is ds5 Are selected.

  If the copy target chunk holding data server identifier and the data server identifier of the writing target chunk holding data server (hereinafter, the writing target chunk holding data server identifier) are the same, the master server 100 moves to step S1705-7. Otherwise, the process proceeds to step S1705-9 (step S1705-6).

  Here, when the copy target chunk holding data server identifier is ds2 or ds4, the process proceeds to step S1705-7, and when the copy target chunk holding data server identifier is ds5, the process proceeds to step S1705-9.

  If the copy target chunk holding data server identifier and the writing target chunk holding data server identifier are the same, the master server 100 sets the writing position chunk identifier as the copy source chunk identifier, and writes the chunk holding data server identifier ds2 (ds4). The local chunk copy request, the copy source chunk identifier, and the write target chunk identifier are transmitted to the write target chunk holding data server 200 (400) identified in step S1705-7 (step S1705-7).

  Then, the master server 100 receives a local chunk copy response from the write target chunk holding data server 200 (400) (step S1705-8).

  If the copy target chunk holding data server identifier and the writing target chunk holding data server identifier are not the same, the master server 100 uses the writing position chunk identifier as a copy source chunk identifier and is identified by the writing target chunk holding data server identifier ds6. The remote chunk copy request, the copy source chunk identifier, the write target chunk identifier, and the copy target chunk holding data server identifier list are transmitted to the write target chunk holding data server 600 (step S1705-9).

  Then, the master server 100 receives a remote chunk copy response from the write target chunk holding data server 600 (step S1705-10).

  When the master server 100 receives the local chunk copy response or receives the remote chunk copy, the master server 100 adds the write target chunk holding data server identifier ds2 (ds4, ds6) to the write target chunk holding data server identifier list (step S1705). -11).

  Then, the master server 100 sets the index to the next position in the copy target chunk holding data server identifier list (step S1705-12).

  When the master server 100 completes the processing of all the copy target chunk holding data server identifiers in the copy target chunk holding data server identifier list, the master server 100 updates the chunk table 112 (step S1705-13). Specifically, the master server 100 registers the write target chunk identifier, the reference count “1”, and the write target chunk holding data server identifier list in the chunk table 112 of the file management unit 110. Also, the master server 100 decreases the reference count value for the write position chunk identifier in the chunk table 112 of the file management unit 110 by one. Further, the master server 100 replaces the write position chunk identifier in the chunk identifier list for the file path name in the file table 111 of the file management unit 110 with the write target chunk identifier.

  Returning to the description of FIG. 19, the master server 100 selects a primary data server and a secondary data server (step S1708). Specifically, the master server 100 selects one arbitrary write target chunk holding data server identifier from the write target chunk holding data server identifier list, and selects the data server identified by the writing target chunk holding data server identifier. The primary data server in this writing is assumed. In addition, a data server identified by another write target chunk holding data server identifier in the write target chunk holding data server identifier list is set as a secondary data server.

  In order to be able to determine which write target chunk holding data server identifier is the data server identifier of the primary data server in the write target chunk holding data server identifier list, for example, the data server identifier of the primary data server is the writing target It should be positioned at the top of the chunk holding data server identifier list. The data server identifier of the primary data server may be determined by other methods.

  Here, as an example, the data server 400 identified by the data server identifier ds4 is the primary data server, and the data server 200 identified by the data server identifier ds2 and the data server 600 identified by the data server identifier ds6 are secondary. Assume that each data server is selected.

  Then, the master server 100 transmits a write control delegation request, the write target chunk identifier, and the write target chunk holding data server identifier list to the data server 400 (step S1709).

  Then, the master server 100 receives a write control delegation response from the data server 400 (step S1710). Subsequently, the master server 100 transmits the write target chunk identifier and the write target chunk holding data server identifier list as chunk information to the external application 700 (step S1711).

  In writing that causes copy-on-write, steps S1706 and S1707 are not executed. Step S1706 is a write process to a chunk that has a reference count value of 1 and is not shared by a plurality of files, and step S1707 is a write process to a write position to which no chunk is allocated.

  Here, the above-described existing chunk processing will be described with reference to FIG. The master server 100 acquires existing chunk information (step S1706-1). Specifically, the master server 100 sets the write position chunk identifier as a write target chunk identifier. Further, the master server 100 acquires a data server identifier list for the write target chunk identifier in the chunk table 112 of the file management unit 110 and sets it as a write target chunk holding data server identifier list.

  Here, the above-described new chunk processing will be described with reference to FIG. The master server 100 executes new chunk processing (step S1707-1 to step S1707-9).

  First, the master server 100 generates a new chunk identifier (hereinafter, write target chunk identifier) and an empty data server identifier list (hereinafter, write target chunk holding data server identifier list) (step S1707-1).

  Then, the master server 100 executes the processing from step S1707-4 to step S1707-7 by the number of redundancy. First, the loop count value is set to 0 (step S1707-2). Subsequently, if the loop count value is smaller than the redundancy number, the process proceeds to step S1707-4, and if not, the process proceeds to step S1707-9 (step S1707-3).

  If the value of the loop count is smaller than the number of redundancy levels, the master server 100 determines a write target chunk holding data server that holds a newly generated chunk (step S1707-4). For example, each of the data servers in which the free capacity of the data storage unit is equal to or greater than a predetermined threshold and the number of chunks having a reference count value of 2 or more among the retained chunks is less than the predetermined threshold. A data server operating on a computer housed in a different rack is selected as a write target chunk holding data server.

  Then, the master server 100 transmits a chunk generation request and the write target chunk identifier to the write target chunk holding data server (step S1707-5). Subsequently, the master server 100 receives a chunk generation response from the write target chunk holding data server (step S1707-6).

  Then, the master server 100 adds the write target chunk holding data server identifier to the write target chunk holding data server identifier list (step S1707-7). Subsequently, the master server 100 increases the value of the loop count by 1 (step S1707-8).

  If the value of the loop count is equal to or greater than the number of redundancy levels, the master server 100 updates the chunk table 112 (step S1707-9). Specifically, the master server 100 registers the write target chunk identifier, the reference count “1”, and the write target chunk holding data server identifier list in the chunk table 112 of the file management unit 110. Further, the master server 100 adds the write target chunk identifier to the write position in the chunk identifier list for the file path name in the file table 111 of the file management unit 110.

[Example of data server processing in write processing]
FIG. 23 is a flowchart illustrating an example of an operation when the data server 200 (400) receives a local chunk copy request from the master server 100 in the writing process according to the first embodiment.

  The data server 200 (400) receives a local chunk copy request, a copy source chunk identifier, and a write target chunk identifier from the master server 100 (step S1801).

  Then, the data server 200 (400) copies the chunk locally (step S1802). Specifically, the data server 200 (400) acquires the chunk storage location and chunk size for the copy source chunk identifier from the chunk information table 211 (411) of the data storage unit 210 (410). The data server 200 (400) copies the chunk stored in the chunk storage location and stores it in the data storage unit 210 (410). Further, the data server 200 (400) registers the write target chunk identifier, the storage location of the copied chunk, and the size of the chunk in the chunk information table 211 (411) of the data storage unit 210 (410).

  Subsequently, the data server 200 (400) transmits a local chunk copy response to the master server 100 (step S1803).

  FIG. 24 is a flowchart illustrating an example of an operation when the data server 600 receives a remote chunk copy request from the master server 100 in the writing process according to the first embodiment.

  The data server 600 receives a remote chunk copy request, a copy source chunk identifier, a write target chunk identifier, and a copy target chunk holding data server identifier list from the master server 100 (step S1901).

  The data server 600 selects a chunk copy source data server from the data servers identified by the copy target chunk holding data server identifier in the copy target chunk holding data server identifier list (step S1902). For example, the closest data server is set as the chunk copy source data server. Here, as an example, it is assumed that the data server 500 is selected as the chunk copy source data server.

  Then, the data server 600 transmits a chunk read request and the copy source chunk identifier to the data server 500 (step S1903). Subsequently, the data server 600 receives a chunk from the data server 500 (step S1904).

  The data server 600 stores the received chunk in the data storage unit 610 (step S1905). Further, the data server 600 registers the write target chunk identifier, the storage location of the stored chunk, and the size of the chunk in the chunk information table 611 of the data storage unit 610. Subsequently, the data server 600 transmits a remote chunk copy response to the master server 100 (step S1906).

  FIG. 25 is a flowchart illustrating an example of an operation when the data server 500 receives a chunk read request from the data server 600 in the writing process according to the first embodiment.

  The data server 500 receives the chunk read request and the copy source chunk identifier from the data server 600 (step S2001). The data server 500 acquires the chunk storage location for the copy source chunk identifier from the chunk information table 511 of the data storage unit 510, and reads the chunk from the data storage unit 510 (step S2002). Subsequently, the data server 500 transmits the chunk to the data server 600 (step S2003).

  FIG. 26 is a flowchart illustrating an example of an operation when the data server receives a chunk generation request from the master server 100 in the writing process according to the first embodiment. Note that the processing shown in FIG. 26 is not executed in the writing that causes copy-on-write. The processing shown in FIG. 26 is executed when step S1707 of FIG. 19 is executed, which is writing to a position where no chunk is allocated.

  The data server receives a chunk generation request and a write target chunk identifier from the master server 100 (step S2101). Then, the data server generates a chunk and updates the chunk information table (step S2102). Specifically, the data server generates an empty chunk and stores it in the data storage unit. In addition, the chunk identifier to be written, the storage location of the chunk, and the size of the chunk (0 at this time) are registered in the chunk information table of the data storage unit. Thereafter, the data server transmits a chunk generation response to the master server 100 (step S2103).

  FIG. 27 is a flowchart illustrating an example of an operation when the data server 400 as the primary data server receives a write control delegation request from the master server 100 in the write processing according to the first embodiment.

  The data server 400 receives a write control delegation request, a write target chunk identifier, and a write target chunk holding data server identifier list from the master server 100 (step S2201).

  Then, the data server 400 holds the write target chunk identifier and the write target chunk holding data server identifier list in the memory (step S2202). Subsequently, the data server 400 transmits a write control delegation response to the master server 100 (step S2203).

  FIG. 28 is a flowchart illustrating an example of an operation when the data server receives a data transmission request from the external application 700 or another data server in the writing process according to the first embodiment. Here, as an example, it is assumed that the data server 200 receives a data transmission request from the external application 700, the data server 400 from the data server 200, and the data server 600 from the data server 400, respectively.

  The data server 200 (400, 600) receives a data transmission request, write target chunk identifier, write data, and write target chunk holding data server identifier list from the external application 700 (data server 200, 400) (step S2301). ).

  Then, the data server 200 (400, 600) holds the write target chunk identifier and the write data in the memory (step S2302).

  Subsequently, the data server 200 (400, 600) deletes its own data server identifier from the write target chunk holding data server identifier list (step S2303).

  If the write target chunk holding data server identifier list is empty, the data server 200 (400, 600) proceeds to step S2307; otherwise, the process proceeds to step S2305 (step S2304). Here, the data servers 200 and 400 transition to step S2305, and the data server 600 transitions to step S2307.

  The data server 200 (400) selects the data server having the closest distance from the data servers identified by the data server identifier in the write target chunk holding data server identifier list, and sends a data transmission request to the selected data server, The write target chunk identifier, the write data, and the write target chunk holding data server identifier list are transmitted (step S2305).

  Here, it is assumed that the data server 200 selects the data server 400 and the data server 400 selects the data server 600 as the closest data server.

  Then, the data server 200 (400) receives a data transmission response from the data server 400 (600) (step S2306). When receiving the data transmission response, the data server 200 (400) transmits the data transmission response to the external application 700 (data server 200) (step S2307). In addition, when the write target chunk holding data server identifier list becomes empty, the data server 600 transmits a data transmission response to the data server 400 (step S2307).

  FIG. 29 is a flowchart illustrating an example of an operation when the data server 400 as the primary data server receives a write request from the external application 700 in the write processing according to the first embodiment.

  The data server 400 receives a write request, a write target chunk identifier, and a write position from the external application 700 (step S2401).

  The data server 400 acquires the chunk storage location for the write target chunk identifier from the chunk information table 411 of the data storage unit 410 (step S2402).

  Subsequently, the data server 400 writes the write data corresponding to the write target chunk identifier held in step S2302 of FIG. 28 at the write position of the chunk (step S2403).

  The data server 400 executes the processing from step S2406 to step S2407 on the data server identifiers of all the secondary data servers in the write target chunk holding data server identifier list held in step S2202. Here, the processing is executed for the data server 200 and the data server 600 which are secondary data servers.

  First, an index indicating the position of the data server identifier in the write target chunk holding data server identifier list is set to the second in the write target chunk holding data server identifier list (step S2404). Here, it is assumed that the data server identifier of the primary data server is located at the head in the write target chunk holding data server identifier list, and the data server identifier of the secondary data server is the second in the write target chunk holding data server identifier list. It shall be located after that.

  Then, the data server 400 transitions to step S2409 when the processing of the data server identifiers of all the secondary data servers in the write target chunk holding data server identifier list is completed. Otherwise, the process proceeds to step S2406 (step S2405).

  If the processing of the data server identifiers of all the secondary data servers in the write target chunk holding data server identifier list is not completed, the data server 400 is the data server at the index position in the write target chunk holding data server identifier list. The secondary write request, the write target chunk identifier, and the write position are transmitted to the data server identified by the identifier (step S2406).

  Subsequently, the data server 400 receives a secondary write response from the data server identified by the data server identifier at the index position in the write target chunk holding data server identifier list (step S2407). The data server 400 sets the index to the next position in the write target chunk holding data server identifier list (step S2408).

  When the processing of the data server identifiers of all the secondary data servers in the write target chunk holding data server identifier list is completed, the data server 400 transmits a write response to the external application 700 (step S2409).

  FIG. 30 is a flowchart illustrating an example of an operation when the data server 200 (600) as the secondary data server receives a secondary write request from the data server 400 as the primary data server in the writing process according to the first embodiment. is there.

  The data server 200 (600) receives the secondary write request, write target chunk identifier, and write position from the data server 400 (step S2501).

  Then, the data server 200 (600) acquires a chunk storage location for the write target chunk identifier from the chunk information table 211 (611) of the data storage unit 210 (610) (step S2502).

  Subsequently, the data server 200 (600) writes the write data corresponding to the write target chunk identifier held in step S2302 of FIG. 28 at the write position of the chunk (step S2503). Then, the data server 200 (600) transmits a secondary write response to the data server 400 (step S2504).

[Effect of the first embodiment]
As described above, the master server 100 according to the first embodiment is a file data stored in a plurality of data servers, and a write request to a snapshot for file data stored in a fixed-length chunk. Is received by the copy-on-write, the data server that is the copy destination of the chunk that is the target of the write request, the free capacity of the data storage unit in each data server, and the data server that holds the chunk to be copied This is determined based on one or more of the distance to each data server, the load state of each data server, and the number of chunks shared by a plurality of files in each data server. Then, the master server 100 controls the determined data server to copy the chunk that is the target of the write request.

  For this reason, in copying a chunk by copy-on-write, it is possible to determine a data server that is a copy destination of the chunk based on a copy-on-write strategy. The copy-on-write strategy is based on the data storage capacity of each data server, the network distance between data servers, the load status of each data server, the number of chunks shared by multiple files on each data server, etc. The data server that is the copy destination of the chunk in copy-on-write is determined by any one or any combination. By using an appropriate copy-on-write strategy according to the assumed use case, chunk copy failure due to insufficient free space in the data storage section of the data server can be prevented, and the load can be distributed among the data servers. It becomes possible.

  In other words, in copy-on-write when writing to the snapshot, the chunks are not copied locally unconditionally in the data server, but the free space of the data storage unit of the data server and the network distance between the data servers Taking into account the load on the data server, etc., copy it locally within the data server or copy it to another data server, avoiding the inability to write due to insufficient free space in the data storage unit, Load can be distributed.

(System configuration etc.)
Further, each component of each illustrated apparatus is functionally conceptual, and does not necessarily need to be physically configured as illustrated. In other words, the specific form of distribution / integration of each device is not limited to that shown in the figure, and all or a part thereof may be functionally or physically distributed or arbitrarily distributed in arbitrary units according to various loads or usage conditions. Can be integrated and configured. For example, the determination unit 113 and the control unit 114 may be integrated. Further, all or any part of each processing function performed in each device may be realized by a CPU and a program analyzed and executed by the CPU, or may be realized as hardware by wired logic.

  In addition, among the processes described in the present embodiment, all or part of the processes described as being automatically performed can be manually performed, or the processes described as being manually performed can be performed. All or a part can be automatically performed by a known method. In addition, the processing procedure, control procedure, specific name, and information including various data and parameters shown in the above-described document and drawings can be arbitrarily changed unless otherwise specified.

(program)
Moreover, it is also possible to create a program in which processing executed by the master server 100 or the data server 200 (300, 400, 500, 600) according to the above embodiment is described in a language that can be executed by a computer. In this case, the same effect as the above-described embodiment can be obtained by the computer executing the program. Further, such a program may be recorded on a computer-readable recording medium, and the program recorded on the recording medium may be read by a computer and executed to execute the same processing as in the above embodiment. In the following, an example of a computer that executes a snapshot control program that realizes the same function as the master server 100 will be described.

  FIG. 31 is a diagram illustrating a computer that executes a snapshot control program. As illustrated in FIG. 31, the computer 10000 includes, for example, a memory 10100, a CPU 10200, a hard disk drive interface 10300, a disk drive interface 10400, a serial port interface 10500, a video adapter 10600, and a network interface 10700. These units are connected by a bus 10800.

  The memory 10100 includes a ROM (Read Only Memory) 10110 and a RAM (Random Access Memory) 10120. The ROM 10110 stores a boot program such as BIOS (Basic Input Output System). The hard disk drive interface 10300 is connected to the hard disk drive 10900. The disk drive interface 10400 is connected to the disk drive 10410. A removable storage medium such as a magnetic disk or an optical disk is inserted into the disk drive 10410, for example. For example, a mouse 11100 and a keyboard 11200 are connected to the serial port interface 10500. For example, a display 11300 is connected to the video adapter 10600.

  Here, as shown in FIG. 31, the hard disk drive 10900 stores, for example, an OS 10910, an application program 10920, a program module 10930, and program data 10940. Each table described in the above embodiment is stored in the hard disk drive 10900 or the memory 10100, for example.

  Further, the snapshot control program is stored in the hard disk drive 10900 as a program module in which a command executed by the computer 10000 is described, for example. Specifically, a program module describing each process executed by the master server 100 described in the above embodiment is stored in the hard disk drive 10900.

  Data used for information processing by the snapshot control program is stored as program data in, for example, the hard disk drive 10900. Then, the CPU 10200 reads out the program module 10930 and the program data 10940 stored in the hard disk drive 10900 to the RAM 10120 as necessary, and executes the above-described procedures.

  Note that the program module 10930 and the program data 10940 related to the snapshot control program are not limited to being stored in the hard disk drive 10900. For example, the program module 10930 and the program data 10940 are stored in a removable storage medium, and the CPU 10200 via the disk drive 10410 or the like. It may be read out. Alternatively, the program module 10930 and the program data 10940 related to the snapshot control program are stored in another computer connected via a network such as a LAN (Local Area Network) or a WAN (Wide Area Network), and the network interface 10700 is stored. Via the CPU 10200.

DESCRIPTION OF SYMBOLS 100 Master server 110 File management part 111 File table 112 Chunk table 113 Determination part 114 Control part 120 Data server state management part 121 Data server state management table 200, 300, 400, 500, 600 Data server 210, 310, 410, 510, 610 Data storage unit 211, 311, 411, 511, 611 Chunk information table 220, 320, 420, 520, 620 Data access unit 230, 330, 430, 530, 630 Status notification unit 700 External application 800 Network 900 File data 910, 920, 930, 1010, 1020, 1030, 1130 Chunk 1000 File 1
1100 File 2
10000 computer 10100 memory 10110 ROM
10120 RAM
10200 CPU
10300 Hard disk drive interface 10400 Disk drive interface 10410 Disk drive 10500 Serial port interface 10600 Video adapter 10700 Network interface 10800 Bus 10900 Hard disk drive 10910 OS
10920 application program 10930 program module 10940 program data 11100 mouse 11200 keyboard 11300 display

Claims (6)

When a write request to a snapshot for file data stored in multiple data servers and stored in fixed-length chunks is received, the target of the write request is made by copy-on-write. The data server that is the copy destination of the chunk, the free space of the data storage unit in each data server, the distance between the data server holding the copied chunk and each data server, the load status of each data server, each data A determining unit that determines based on any one or more of the number of chunks shared by a plurality of files on the server;
A snapshot control apparatus comprising: a control unit that controls a data server determined by the determination unit to copy a chunk that is a target of a write request.   The determining unit selects a data server having the smallest distance from the data server holding the chunk to be copied from among the data servers in which the free space of the data storage unit in the data server is equal to or greater than a predetermined threshold. The snapshot control apparatus according to claim 1, wherein the snapshot control apparatus is determined as a data server.   The determination unit determines a data server having the lowest load state as a copy destination data server from among data servers in which a free space of a data storage unit in the data server is equal to or greater than a predetermined threshold. Item 4. The snapshot control device according to Item 1.   The determination unit is a data server in which the free space of the data storage unit in the data server is equal to or greater than a predetermined threshold, and the number of chunks shared by a plurality of files in each data server is less than the predetermined threshold 2. The snapshot control apparatus according to claim 1, wherein the server is determined as a copy destination data server. A snapshot control method executed by a snapshot control device,
When a write request to a snapshot for file data stored in multiple data servers and stored in fixed-length chunks is received, the target of the write request is made by copy-on-write. The data server that is the copy destination of the chunk, the free space of the data storage unit in each data server, the distance between the data server holding the copied chunk and each data server, the load status of each data server, each data A determination step of determining based on any one or more of the number of chunks shared by the plurality of files on the server;
And a control step of controlling the data server determined by the determination step so as to copy the chunk that is the target of the write request. When a write request to a snapshot for file data stored in multiple data servers and stored in fixed-length chunks is received, the target of the write request is made by copy-on-write. The data server that is the copy destination of the chunk, the free space of the data storage unit in each data server, the distance between the data server holding the copied chunk and each data server, the load status of each data server, each data A decision step for determining based on any one or more of the number of chunks shared by the plurality of files on the server;
A snapshot control program that causes a computer to execute a control step of controlling a data server determined in the determination step to copy a chunk that is a target of a write request.

Images