WO2017056145A1 - Storage system, storage device, and storage control method - Google Patents

Abstract

The purpose of the present invention is to maintain consistency between objects in a storage device and objects in an object storage device, even if a failure occurs when the storage device is updating an object in the object storage device. The object storage device stores each version of each of one or more specific objects. When the storage device refers to a specific object stored therein, the storage device determines whether or not the specific object in the object storage device corresponding to the referred-to specific object in the storage device is locked, and if it is determined that the specific object in the object storage device is locked, then the storage device retrieves the last unlocked version of the specific object in the object storage device, and restores the specific object in the storage device to match the retrieved last unlocked version.

Description

[Supplement based on Rule 26 08.10.2015] Storage system, storage device, and storage system control method

The present invention relates to a storage system.

There is known a system in which NAS (Network Attached Storage) arranged in each of a plurality of bases such as a company branch shares the same file or directory via CAS (Content Addressed Storage). Users at each site create and store multiple directories on the NAS to classify and store files. Therefore, in order for a plurality of sites to access the same file, it is necessary to maintain the consistency of this directory structure.

The NAS at each site acquires information on directory operations performed at other sites in order to maintain the consistency of the directory structure, and reflects the operation in its own file system. With this process, the directory tree can be synchronized among a plurality of NAS.

Patent Document 1 describes a method in which CAS manages a directory operation transaction. When the first client system changes the contents of the directory, the change is reflected in the directory stored in the CAS, and a commit operation to the CAS is executed. The CAS treats only the update that has been committed as a valid update, so that the second client system can obtain only the version that has been committed. Therefore, when a failure occurs during the update of the directory by the first client system, the commit operation has not been performed, so the directory that was being updated cannot be acquired from the second client system.

Patent Document 2 describes a file and directory synchronization method using an update list. When the first NAS updates a file or directory, it transfers the updated list of files and directories to the CAS as an update list. The second NAS obtains this update list from the CAS, and sets a synchronization required flag for the files and directories described in the update list. Thereafter, when the end user of the second NAS accesses the file or directory in which the synchronization required flag is set, the second NAS acquires the latest version of the file or directory from the CAS.

Patent Document 3 describes a technique for acquiring a lock when NAS updates a directory in order to exclude updating of the same directory between NASs. When the NAS updates the directory, it first acquires a lock, then updates the CAS directory, and finally releases the lock.

U.S. Pat. No. 8,825,597 US Patent Application Publication No. 2012/0259813 International Publication No. 2014/128819

Even if the NAS uses the processing procedure to acquire the lock of the directory to be updated in CAS, the directory structure may be inconsistent. For example, after a first update is performed on a specific directory in the CAS, the specific NAS may perform a second update and a failure may occur in the specific NAS before sending an update list. The NAS that accesses the specific directory between the first update and the second update and acquires the first update does not subsequently acquire the second update. A NAS that does not access the specific directory between the first update and the second update and has not acquired the first update subsequently acquires the second update. In this way, NAS that is synchronized with the second update and NAS that are not so are mixed, and the consistency of the directory structure between NAS may be lost.

In order to solve the above problems, a storage system according to one aspect of the present invention includes an object storage device and a storage device connected to the object storage device. When the storage apparatus receives an update request for requesting an update of a specific object in the storage apparatus, the storage apparatus requests the object storage apparatus to lock the specific object in the object storage apparatus, and the specific object in the storage apparatus The updated specific object is transmitted to the object storage device, and the object storage device is requested to release the lock of the specific object, and the object storage device stores the specific object for each version. When the storage device refers to a specific object in the storage device, the storage device determines whether or not the specific object in the object storage device is locked. When it is determined that the fixed object is locked, the storage apparatus acquires from the object storage apparatus the specific object of the immediately previous version that is the version immediately before the determined lock, and the specific object in the storage apparatus Is matched with the specific object of the previous version.

Even if a failure occurs while the storage device is updating an object in the object storage device, it is possible to maintain consistency between the object in the storage device and the object in the object storage device.

1 shows an overview of a computer system according to an embodiment of the present invention. It is a block diagram which shows schematic structure of a computer system. 2 is a block diagram showing a configuration of a NAS 300. FIG. 2 is a block diagram showing a configuration of CAS400. FIG. A configuration example of file / directory management information 500 in the NAS 300 is shown. The structural example of the directory lock management information 600 in NAS300 is shown. 2 shows a configuration example of object management information 700 in CAS 400. 10 shows a configuration example of lock state management information 800 in the CAS 400 of the first and second embodiments. 12 is an example of a flowchart for explaining details of a directory synchronization process 900 according to the first and third embodiments. 5 is an example of a flowchart for explaining details of a synchronization version determination process 1000 according to the first embodiment. 10 is an example of a flowchart for explaining details of CAS data acquisition processing 1100 according to the first and third embodiments. 6 is an example of a flowchart for explaining details of rollback processing 1200; 12 is an example of a flowchart for explaining details of directory creation processing 1300; 12 is an example of a flowchart for explaining details of directory deletion processing 1400; 12 is an example of a flowchart for explaining details of update list acquisition / application processing 1500; 12 is an example of a flowchart for explaining details of object storage processing 1600; 12 is an example of a flowchart for explaining details of an object reading process 1700 in the first and third embodiments. 12 is an example of a flowchart for explaining details of directory lock processing 1800. 12 is a flowchart for explaining details of directory synchronization processing 1900 according to the second embodiment. 12 is an example of a flowchart for explaining details of CAS data acquisition processing 2000 according to the second embodiment. 12 is an example of a flowchart for explaining details of an object reading process 2100 according to the second embodiment. 10 shows a configuration example of lock state management information 2200 in CAS 400 of the third embodiment. 12 is an example of a flowchart for explaining details of directory lock processing 2300; FIG. 10 is an example of a flowchart for explaining details of a synchronization version determination process 2400 in the third embodiment.

Hereinafter, embodiments of the present invention will be described with reference to the drawings.

Hereinafter, an embodiment of the present invention will be described with reference to the accompanying drawings by taking a computer system including a NAS, a client PC, and CAS as an example. However, this embodiment is only an example for realizing the present invention, and does not limit the technical scope of the present invention.

In the following description, information may be described in terms of “xxx information” or the like, but the information may be expressed in any data structure. That is, such information can be called by other names such as “xxx table”, “xxx database”, and the like. In the following description, the configuration of each information is an example, and one piece of information may be divided into two or more pieces of information, or all or a part of two pieces or more pieces of information may be one piece of information. Good.
In the following description, an ID is used as element identification information, but other types of identification information may be used instead of or in addition to the ID.

In the following description, when a description is made without distinguishing the same type of element, a reference number or a common number in the reference number is used, and when a description is made by distinguishing the same type of element, the reference number of the element is used. Or the ID assigned to the element may be used instead of the reference sign.

In the following description, the process may be described using “program” as the subject, but the program is executed by a processor (for example, a CPU (Central Processing Unit)), so that a predetermined process can be appropriately performed. Since processing is performed using a storage resource (for example, a memory) and / or an interface device (for example, a communication port), the subject of processing may be a processor. The process described with the program as the subject may be a process or system performed by a processor or an apparatus having the processor. The processor may include a hardware circuit that performs a part or all of the processing. The program may be installed in a computer-like device from a program source. The program source may be, for example, a storage medium that can be read by a program distribution server or a computer. When the program source is a program distribution server, the program distribution server may include a processor (for example, CPU) and a storage resource, and the storage resource may further store a distribution program and a program to be distributed. Then, the processor of the program distribution server executes the distribution program, so that the processor of the program distribution server may distribute the distribution target program to other computers. In the following description, two or more programs may be realized as one program, or one program may be realized as two or more programs.

In addition, as will be described later, the embodiment of the present invention may be implemented by software operating on a general-purpose computer, or may be implemented by dedicated hardware or a combination of software and hardware.

In the embodiment of the present invention, the communication network of the NAS and CAS is not limited to the use of the WAN, and a communication network such as a LAN (Local Area Network) can also be employed. The embodiment of the present invention is not limited to adopting the NFS (Network File System) protocol, but can also employ other file sharing protocols including CIFS (Common Internet File System), HTTP (Hypertext Transfer Protocol), and the like. is there.

In the following description, the term “object” is used as a general term for files and directories. In the following description, the process for a directory may be a process for an object. In other words, the process for the file can be executed similarly to the process for the directory.

FIG. 1 shows an outline of a computer system according to an embodiment of the present invention.

This computer system is distributed in the data center and bases X, Y, and Z.

In the base X, a NAS 300X and a client PC (Personal Computer) 201X connected to the NAS 300X via an internal network such as a LAN (Local Area Network) are arranged. The end user operates files and directories via the client PC. Similarly, NAS 300Y and client PC 201Y connected to NAS 300Y via a network are arranged at site Y, and NAS 300Z and client PC (not shown) connected to NAS 300Z via the network are arranged at site Z. Are arranged). Hereinafter, when it is not necessary to distinguish between the base X, the base Y, and the base Z, the alphabet of the symbol is omitted.

∙ CAS400 is located in the data center. The NAS 300 is connected to the CAS 400 via an external network such as a WAN (Wide Area Network). A system including CAS 400 and at least one NAS 300 may be referred to as a storage system.

When the internal object is updated, the NAS 300 transfers the updated object to the CAS 400 and transfers an “update list” that describes the path of the updated object to the CAS 400. The CAS 400 stores the transferred update list file for each version. The NAS 300 can notify other NAS of local object updates using this update list. The other NAS 300 detects the update of the object by acquiring this update list from the CAS 400. When the NAS 300 acquires the update list, the NAS 300 sets a “synchronization required flag” to the object described in the update list. Thereafter, when the user of the NAS 300 accesses an object for which the synchronization required flag is set, the NAS 300 can synchronize the object with the latest version on the CAS 400.

NAS 300 stores a file system including directories and files as elements. In accordance with a request from the client PC 201, the NAS 300 executes directory update operations such as directory creation, deletion, migration, and rename. The target of the update operation may be a file. In this example, the end user of the NAS 300X requests creation of / A / C (S1). At this time, first, the NAS 300X locks the target directory on the CAS 400. While locked, other NAS 300 cannot update the target directory. In this example, the NAS 300X locks the directory A (S2). Next, the NAS 300X performs a directory update operation requested by the end user on the local file system 318X. In this example, the NAS 300X creates a directory C under the existing directory A in the local file system 318X (S3). Next, the NAS 300X creates an update list indicating the executed directory update operation. In this example, since the NAS 300X has created the directory C under the directory A, the NAS 300X creates an update list in which the directory A and the directory C are described (S4). Next, the NAS 300X transfers the updated directory data and the update list indicating the updated directory to the CAS 400. Thereafter, the NAS 300X unlocks the directory A. However, in this example, the NAS 300X has failed to transfer the update list due to the occurrence of a failure after transferring the directory to the CAS 400 (S5) (S6). At this time, the directory A is not unlocked but remains locked.

Even if the transfer of the update list by the NAS 300X fails, the other NAS 300 that has been set with the synchronization required flag set in the directory A performs the synchronization process of the directory A according to the user's access to the directory A. Execute. In the example of FIG. 1, such another NAS 300X is the NAS 300Y of the base Y.

If the method of Patent Document 2 is used, NAS300 synchronizes with the latest version of CAS400. In this case, when the user accesses the directory A in the NAS 300Y, since the synchronization required flag is set in the directory A, the NAS 300Y synchronizes with the latest version of the directory A. As a result, a directory C is created in the NAS 300Y. At this time, in the NAS 300Z, since the synchronization required flag is not set for the directory A, the directory A synchronization processing is not executed. Therefore, the directory C is not created in the NAS 300Z. Therefore, consistency is lost between NAS300Y and NAS300Z.

Therefore, this problem is solved by the method of the embodiment shown in FIG. When the user of the NAS 300Y accesses the directory A (S6), the NAS 300Y confirms the locked state of the directory A with the CAS 400 (S8). At this time, the directory A remains locked due to the occurrence of a failure in the NAS 300X. Next, the NAS 300Y inquires of the CAS 400 about the time when the directory A is locked (S9). The locked time in this example is 10:00:00. Next, the NAS 300Y synchronizes with the latest version that is older than the locked time. In this example, the NAS 300Y synchronizes with the directory A at 9:50:00, which is older than 10:00:00 and is the latest (S10). As a result, the NAS 300Y can be synchronized with the state before the directory C is created, and can maintain consistency with the NAS 300Z. Here, the NAS 300 regards the unlock in the directory update as the close of the update transaction, reflects the update closed by the transaction to the file system 318, and does not reflect the update not closed by the transaction to the file system 318.

The NAS300X in which the failure has occurred performs rollback processing by itself to return the file system 318X to the state before directory creation. Thereby, the consistency of the directory structure can be maintained among all the NAS 300.

Note that other storage devices may be used instead of the NAS 300. Instead of the CAS 400, another object storage device may be used.

FIG. 2 is a block diagram showing a schematic configuration of the computer system.

The computer system of the present embodiment is distributed in at least one base and one data center, and the base and the data center are connected via the WAN 203. In FIG. 2, there are only two bases, the base X and the base Y, but any number of bases may be used.

Each site includes client PC201, NAS300, LAN202.

The client PC 201 is a computer used by an end user in order to use the file sharing service provided by the NAS 300. On the client PC 201, a client program that communicates with the NAS runs. Based on the operation of the end user, the client PC 201 issues a request for creating, deleting, moving, renaming, reading data, writing, and the like to the NAS 300.

The LAN 202 is a network that connects the client PC 201 and the NAS 300 to each other.

NAS300 is a computer that provides file sharing services to end users. The configuration of the NAS 300 will be described later.

The WAN 203 is a network connecting the network 202 of each base and the data center. The NAS 300 and CAS 400 communicate via this network. For this communication, for example, a communication protocol such as HTTP (Hypertext TransfercolProtocoly) or HTTPS (Hypertext Transfer Protocol 等 Secure) is used.

The data center has CAS400. The configuration of CAS 400 will be described later. The CAS 400 may take a cluster configuration including a plurality of nodes.

FIG. 3 is a block diagram showing the configuration of the NAS 300.

The NAS 300 includes a NAS controller 301 and a storage device 322.

The NAS controller 301 includes an I / F (Interface) 302, a CPU 303, a network I / F 304, and a memory 305. Each unit of the NAS controller 301 is connected to each other by an internal communication path (for example, a bus).

The I / F 302 is used for connection to the storage device 322, and the NAS controller 301 reads / writes data from / to the storage device 322 via the I / F 302.

The CPU 303 executes data read / write processing on the storage device 322 according to the program and data in the memory 305.

The network I / F 304 is connected to the client PC 201 and CAS 400 via the LAN or WAN, and communicates with the client PC 201 or CAS 400.

The memory 305 stores programs and data for controlling the NAS 300. The memory 305 includes a directory synchronization program 306, a directory lock program 307, an update list acquisition / application program 308, a migration program 309, a rollback program 310, a file sharing program 311, a file system program 312, Stores directory management information 500, acquired directory lock management information 600, and CAS information 313.

The directory synchronization program 306 is a program that synchronizes the directory with the directory on the CAS 400 when the end user accesses the directory for which the synchronization required flag is set. The directory synchronization program includes a directory synchronization process 900, a synchronization version determination process 1000, and a CAS data acquisition process 1100. Details of each process will be described later.

The directory lock program 307 is a program for acquiring and releasing a directory lock on the CAS 400. The directory lock program 307 includes a directory lock process and a directory lock release process.

The directory lock acquisition process is executed by the CPU 303 of the NAS 300 in response to a call from the directory creation process 1300 or the directory deletion process 1400.

In the directory lock acquisition process, the object ID specified by the argument is used as an argument, and the CAS 400 is requested to execute the directory lock process 1800 in the first and second embodiments and the directory lock process 2300 in the third embodiment. Acquires the directory lock for the specified directory. Details of the directory lock processing 1800 and the directory lock processing 2300 will be described later.

The directory lock release process is executed by the CPU 303 of the NAS 300 in response to a call from the directory creation process 1300 or the directory deletion process 1400. The directory lock release process requests the CAS 400 to execute the directory unlock process using the object ID specified by the argument as an argument, thereby releasing the directory lock of the directory specified by the argument. Details of the CAS400 directory lock release processing will be described later.

The update list acquisition / application program 308 acquires the update list from the CAS 400, sets the synchronization required flag for the object whose path is described in the acquired update list, and the directory for which the synchronization required flag is set is about to be updated. This is a program that calls the directory synchronization processing 900 if the directory is a directory. The update list acquisition / application program 308 includes an update list acquisition / application process 1500. Details of the processing will be described later.

The migration program 309 includes migration processing. The migration process requests the CAS400 to execute the object storage process 1600, so that the files and directories updated in the NAS300 file system 318 are stored in the CAS400 and the path names of these files and directories are described. The update list is also a program that saves this update list in CAS 400 by requesting CAS 400 to execute object storage processing 1600. Note that the migration process also deletes files and directories on the CAS 400 for files and directories deleted on the file system 318. Details of the object storage processing 1600 will be described later.

The rollback program 310 is a program that is executed when the migration process fails and returns the update to the file system 318 that failed the migration process to the state before the update. The rollback program includes a rollback process 1200. Details of the rollback processing 1200 will be described later.

The file sharing program 311 and part or all of the file system 318 are “shared” and are disclosed to the client PC 201 to provide a file sharing service to the end user. The file sharing service communicates with a client PC using a protocol such as CIFS (Common Internet File System) or NFS (Network File System).

The file system program 312 is a program for managing the file system 318 stored in the disk 317 in the storage device 322. The NAS 300 uses the file system program 312 to operate the root directory 319, the file 320, and the directory 321 created in the file system 318. That is, another program stored in the memory 305 calls the file system program 312 and operates the root directory 319, the file 320, and the directory 321 created in the file system 318. For example, when creating a directory, a directory creation process 1300 of the file system program 312 is executed. Further, when deleting a directory, a directory deletion process 1400 of the file system program 312 is executed. The root directory is a name of the highest directory in the hierarchical directory structure.

The file / directory management information 500 is information for managing files and directories stored in the file system 318. Details of a data configuration example of the file / directory management information 500 will be described later. The file / directory management information 500 may be stored in the disk 317.

The directory lock management information 600 is information for managing whether the NAS 300 has acquired the directory lock of each directory by itself. Details of the data configuration example of the directory lock management information 600 will be described later. The directory lock management information 600 may be stored on the disk 317.

CAS information 313 is information for NAS 300 to communicate with CAS 400. For example, information such as a URL (Uniform Resource Locator) and a protocol used for communication. The CAS information 313 may be information of a plurality of CAS 400. The CAS information 313 may be stored in the disk 317.

The storage device 322 includes an I / F 314, a memory 315, a CPU 316, and a disk 317. Each unit of the storage device 322 is connected to each other by an internal communication path (for example, a bus).

The I / F 314 is connected to the NAS controller 301 and communicates with the NAS controller 301.

The memory 315 stores a program and data for controlling the storage device 322.

The CPU 316 performs processing such as writing to and reading from the disk 317 according to the program and data in the memory 315.

The disk 317 is a non-volatile storage medium such as an HDD (Hard Disk Drive) or an SSD (Solid State Drive). A file system 318 is constructed on the disk 317 by the file system program 312. As a result, the disk 317 stores directories and files. The disk 317 may be a plurality of disks.

The file system 318 is managed by the file system program 312 and stores files 320 and directories 321 created / updated by the end user. The file system 318 has a hierarchical structure with the root directory 319 as the highest level. That is, a plurality of directories can be created under the directory. There may be a plurality of file systems 318.

Note that the NAS controller 301 may be referred to as a controller. In addition, the disk 317 may be referred to as a storage device.

FIG. 4 is a block diagram showing the configuration of CAS400.

The CAS 400 includes a CAS controller 401 and a storage device 402.

The CAS controller 401 includes a network I / F 403, an I / F (Interface) 404, a CPU 405, and a memory 406. Each part of the CAS controller 401 is connected to each other by an internal communication path (for example, a bus).

The network I / F 403 is connected to the NAS 300 via the WAN and used to communicate with the NAS 300.

The I / F 404 is used for connection with the storage device 402. The CAS controller 401 reads / writes data from / to the storage device 402 via the I / F 404.

The CPU 405 executes processing of the object operation program 407 and the file system program 408 according to the program and data in the memory.

The memory 406 stores a program and data for controlling the CAS 400. The memory 406 includes an object operation program 407, a file system program 415, object management information 700, and lock state management information 800.

The object operation program 407 executes processing such as reading / writing of files and directories stored in the file system 413, acquisition of a list of versions, locking, unlocking, lock confirmation, acquisition of lock time, etc. according to a request from the NAS 300, and the result To the NAS300. The object operation program 407 includes an object storage process 1600, an object read process 1700, a directory lock process 1800, a directory unlock process, a version list acquisition process, a lock confirmation process, and a lock time acquisition process. Details of each process will be described later.

The file system program 408 is a program for managing the file system 413. The file system program 408 reads / writes the object stored in the file system 413 based on the request from the object operation program 407.

The object management information 700 is information for managing files and directories stored in the file system 413 in response to a request from the NAS 300. Details of a data configuration example of the object management information 700 will be described later. The object management information 700 may be stored on the disk 412.

The lock status management information 800 is information for managing the lock status of each directory. Details of the data configuration example of the lock state management information 800 will be described later. The lock state management information 800 may be stored in the disk 412.

The storage device 402 includes an I / F 409, a memory 410, a CPU 411, and a disk 412. Each unit of the storage device 402 is connected to each other by an internal communication path (for example, a bus).

The I / F 409 is connected to the CAS controller 401 and communicates with the CAS controller 401.

The memory 410 stores a program and data for controlling the storage device 322.

The CPU 411 performs processing such as writing to and reading from the disk 412 according to the program and data in the memory 410.

The disk 412 is a non-volatile storage medium such as an HDD (Hard Disk Drive) or an SSD (Solid State Drive). A file system 413 managed by the file system program 408 is constructed on the disk 412. As a result, the disk 412 stores directories and files. The disk 412 may be a plurality of disks.

The file system 413 is managed by the file system program 408. The file system 413 stores files and directories in response to requests from the NAS 300. A plurality of file systems 413 may be provided.

FIG. 5 shows a configuration example of the file / directory management information 500 in the NAS 300.

The file / directory management information 500 includes an entry for each object. The file / directory management information 500 includes a path name 501, a type 502, an object ID 503, and a synchronization required flag 504 as one entry.

The path name 501 is the path name of the object in the file system 318.

Type 502 is the type of the object indicated by the path name 501. For example, a file or a directory.

The object ID 503 is an identifier on the CAS 400 of the object indicated by the path name 501. That is, when the NAS 300 operates an object on the CAS 400, the NAS 300 requests the CAS 400 as processing for the object ID 503. The path name 501 and the object ID 503 may be the same. When the path name 501 and the object ID 503 are the same, the file / directory management information 500 may not have the object ID 503. If the path name 501 and the object ID 503 are the same character string, the process of converting the path name 501 to the object ID 503 with reference to the file / directory management information 500 in the following description can be omitted.

The synchronization required flag 504 is information indicating whether or not it is necessary to synchronize with the object in the CAS 400. If the synchronization required flag 504 is ON, synchronization is required, and if the synchronization required flag is OFF, it indicates that synchronization is not required.

Each program stored in the memory 305 of the NAS 300 refers to the file / directory management information 500 and converts the path name in the file system 318 to an object ID that is an object identifier in the CAS 400. For example, synchronous version confirmation processing 1000 included in the directory synchronization program 306, on-CAS data acquisition processing 1100, directory lock acquisition processing included in the directory lock program 307, directory lock release processing, and update list acquisition / application The update list acquisition / application process 1500 included in the program 308 and the migration process included in the migration program 309 perform this conversion. In addition, the update list acquisition / application process 1500 included in the update list acquisition / application program 308 and the directory synchronization process included in the directory synchronization program 306 update the synchronization required flag 504.

FIG. 6 shows a configuration example of the directory lock management information 600 in the NAS 300.

The directory lock management information 600 includes an entry for each object. The directory lock management information 600 includes a base name 601, an object ID 602, a lock state 603 by the own NAS (local NAS 300), and a lock count 604 as one entry.

The site name 601 is the name of the site where the NAS 300 is installed. In the example of FIG. 6, since it is the NAS 300 installed at the base X, the base name 601 of each entry is X.

The object ID 602 is an object identifier on the CAS 400.

The lock state 603 by the own NAS is information indicating whether or not the directory indicated by the object ID 602 is locked by the NAS 300 installed at the site name 601. The lock state 603 by the own NAS indicates that the directory indicated by the object ID 602 is locked if the lock has been acquired by the NAS 300 installed in the site name 601 and is not locked otherwise. Further, the directory lock process and the directory lock release process included in the directory lock program 307 update the lock state 603 of the directory lock management information 600 by the own NAS.

The lock count 604 is the number of update processes that are being executed (locked) by the NAS 300 corresponding to the site name 601 for the directory indicated by the object ID 602. The directory creation process 1300 and the directory deletion process 1400 update the lock count 604 of the directory lock management information 600.

For example, object update processing, such as directory creation processing 1300 and directory deletion processing 1400, when updating multiple child directories under the parent directory, locks the parent directory in each update of multiple child directories. Rather than acquiring, update multiple child directories with the parent directory lock acquired. Thereby, the update process can execute the update of a plurality of child directories in parallel. The update process locks the parent directory first, then increases the parent directory lock count 604 before updating the child directory, and after updating the child directory, decreases the parent directory lock count 604, When the lock count 604 reaches 0, the parent directory is unlocked. As a result, the NAS 300 that performs the update process can execute a plurality of updates all together, and can prevent other NAS 300 from updating those directories. In addition, the time required for updating a plurality of objects can be reduced and the performance can be improved as compared with the case of locking each update.

Each program stored in the memory 305 of the NAS 300 refers to the directory lock management information 600 to confirm the lock state 603 and the lock count 304 of the directory by its own NAS. For example, the directory creation processing 1300 and the directory deletion processing 1400 included in the file system program 312 refer to the directory lock management information 600 and confirm the lock state of the processing target directory.

FIG. 7 shows a configuration example of the object management information 700 in the CAS 400.

The object management information 700 includes an entry for each version. The object management information 700 includes an object ID 701, a version 702, a creation time 703, and a path name 704 as one entry.

The object ID 701 is an identifier that the CAS 400 provides to the NAS 300 as information that specifies the object to be processed.

Version 702 is an identifier for uniquely identifying one of a plurality of generations of the object ID 701. One or more versions 702 exist for one object ID 701.

The creation time 703 is the time when the version 702 of the object ID 701 is created in the file system 413 of the CAS 400 at the request of the NAS 300.

The path name 704 is a path name of a file / directory where the data indicated by the object ID 701 and the version 702 is stored. This path name is a path name in the file system 413 in the CAS 400.

The object storage processing 1600 included in the object operation program 407 recognizes the latest version of the object specified in the NAS 300 based on the object management information 700 and adds an entry to the object operation program 407.

Also, the object reading process 1700 included in the object operation program 407 acquires the path name 704 corresponding to the object ID and version specified by the NAS 300 from the object management information 700.

FIG. 8 shows a configuration example of the lock state management information 800 in the CAS 400 according to the first and second embodiments.

The lock state management information 800 includes an entry for each object. The lock state management information 800 includes an object ID 801, a lock file 802, a lock state 803, a lock time 804, and a relock time 805 as one entry.

The object ID 801 is an identifier for identifying an object.

The lock file 802 is a path name of a file created to indicate that the object indicated by the object ID 801 is locked. This path name is a path name in the file system 413 in the CAS 400.

The lock state 803 is information indicating whether or not the object indicated by the object ID 801 is locked.

The lock time 804 is the time when the object indicated by the object ID 801 is locked. The lock time 804 is set only when the object is locked.

The re-lock time 805 indicates the time when the object indicated by the object ID 801 is locked at the time indicated by the lock time 804 and the object is subsequently re-locked after the lock expires. The relock time 805 is set only when the object is relocked.

The lock expires when the time equal to or greater than the preset lock time threshold elapses from the latest lock time, which is the time at which the latest lock was acquired among the lock time 804 and the relock time 805, and all NAS 300 acquires the lock Allow to do. The most recent time among the times relocked after the expiration of the lock is recorded as the relock time 805. In other words, the lock time 804 is the time when the lock is first performed, and the relock time 805 is the latest time when the lock is not unlocked after the lock time 804.

The lock confirmation process and the lock time acquisition process included in the object operation program 407 acquire the lock state 803 and the lock time 804 of the specified object by referring to the lock state management information 800. Further, the directory lock process 1800 and the directory unlock process included in the object operation program 407 refer to and update the lock state management information 800.

FIG. 9 is an example of a flowchart for explaining details of the directory synchronization processing 900 according to the first and third embodiments.

The directory synchronization processing 900 is triggered by either the call from the update list acquisition / application processing 1500 or the access by the end user of the NAS 300 to the directory for which the synchronization required flag 504 of the file / directory management information 500 is ON. , Executed by the CPU 303 of the NAS300.

First, the directory synchronization program 306 calls the synchronization version determination process 1000 using the path name to be processed received as an argument as an argument, and acquires a synchronized version (S901).

Next, the directory synchronization program 306 calls the CAS data acquisition processing 1100 using the path name of the processing target received as an argument and the version obtained as the processing result of the synchronization version confirmation process (S901) as an argument in the CAS 400. The processing target directory is acquired (S902).

Next, the directory synchronization program 306 executes directory reading processing on the NAS using the path name of the processing target received as an argument, and reads the processing target directory stored in the file system 318 by the NAS 300 (S903). The directory reading process on the NAS uses the file system program 312 to read the directory specified by the argument from the file system 318.

Next, the directory synchronization program 306 compares the directory obtained as a result of the CAS data acquisition process (S902) with the directory obtained as a result of the NAS directory read process (S903). As a result, the directory synchronization program 306 extracts the directory entry that has been created or deleted in the directory acquired from the CAS 400, and performs the same operation on the directory of the file system 318 of the NAS 300 (S904). In order to perform this operation, the directory synchronization program 306 calls the file system program 312.

Next, when the processing result of the synchronization version confirmation processing (S901) is the latest version (when S905 is Yes), the directory synchronization program 306 receives the path to be processed received as an argument in the file / directory management information 500 The synchronization necessity flag 504 of the entry having the path name 501 that matches the name is changed to OFF (S906).

On the other hand, when the processing result of the synchronization version confirmation processing (S901) is not the latest version (when S905 is No), the directory synchronization program 306 receives the path name of the processing target received as an argument in the file / directory management information 500 The synchronization necessity flag 504 of the entry having the path name 501 that matches with is kept ON (S907).

According to the above processing, the NAS 300 cancels the synchronization required flag when the object in the file system matches the latest version in the CAS 400, and makes the object in the file system match the version immediately before the update in the CAS 400. If the synchronization necessity flag is maintained, an object that is not the latest version can be resynchronized by the subsequent directory synchronization processing.

FIG. 10 is an example of a flowchart for explaining details of the synchronization version determination process 1000 according to the first embodiment.

The synchronization version confirmation process 1000 is executed by the CPU 303 of the NAS 300 in response to a call from the directory synchronization process 900.

First, the directory synchronization program 306 refers to the file / directory management information 500, converts the path name of the processing target received as an argument into an object ID, and confirms the lock to the CAS 400 using the object ID of this conversion result as an argument. Request execution of processing (S1001).

CAS 400 executes lock confirmation processing using the object ID received from NAS 300 as an argument (S1002). In the lock confirmation processing, the lock state 803 of the entry having the object ID 801 that matches the object ID received as an argument in the lock state management information 800 is returned to the NAS 300.

If the processing result of the lock confirmation processing (S1002) is not locked (if S1003 is No), the directory synchronization program 306 determines the result of the synchronization version confirmation processing 1000 as the latest version and returns it to the caller (S1004).

On the other hand, if the processing result of the lock confirmation processing (S1002) is already locked (if S1003 is Yes), the directory synchronization program 306 uses the object ID corresponding to the path name of the processing target received as an argument as an argument Then, the CAS 400 is requested to execute the lock time acquisition process (S1005).

CAS 400 executes the lock time acquisition process using the object ID received from NAS 300 as an argument (S1006). In the lock time acquisition process, the lock time 804 of the entry having the object ID 801 that matches the object ID received as an argument in the lock state management information 800 is returned to the NAS 300.

Next, the directory synchronization program 306 requests the CAS 400 to execute the version list acquisition process of the processing target directory, using the object ID corresponding to the processing target path name received as the argument (S1007).

CAS 400 executes version list acquisition processing using the object ID received from NAS 300 as an argument (S1008). In the version list process, the object management information 700 is searched, and all entries corresponding to the object ID received as an argument by the object ID 701 are extracted and returned to the NAS 300. That is, the version list is information on all versions of the object identified by the object ID. Note that a device connected to the CAS 400 may acquire a version list in order to select a specific version from a plurality of snapshot versions in the CAS 400.

Next, the directory synchronization program 306 includes the creation time of each version included in the version list acquired as the processing result of the version list acquisition processing (S1008), the lock time acquired as the processing result of the lock time acquisition processing (S1006), , And the latest version among the versions having the creation time older than the lock time (version immediately before the lock time) is searched. The result of the synchronization version determination process 1000 is determined as the version obtained as the search result and returned to the caller (S1009).

According to the synchronous version determination process 1000 described above, when it is determined that the object to be processed is not locked, the NAS 300 acquires the object of the latest version from the CAS 400, thereby acquiring the object in the file system 318. Can be synchronized to the version that has been updated. If it is determined that the object to be processed is locked, the NAS 300 obtains the object of the version immediately before the update from the CAS 400, so that the update of the object in the file system 318 has been completed. You can avoid syncing to no version. With these operations, the consistency of the file systems 318 of the plurality of NAS 300 can be maintained. The NAS 300 can determine the creation time of the version immediately before the update by acquiring the lock time from the CAS 400. Further, the NAS 300 can identify the version immediately before the update by acquiring the version list from the CAS 400.

FIG. 11 is an example of a flowchart for explaining details of the on-CAS data acquisition processing 1100 according to the first and third embodiments.

The CAS data acquisition process 1100 is executed by the CPU 303 of the NAS 300 in response to a call from the directory synchronization process 900 in the first and third embodiments.

First, when the acquisition target version is not specified by the argument (when S1102 is No), the directory synchronization program 306 refers to the file / directory management information 500 and sets the processing target path name received as the argument to the object. Conversion to ID is performed, and this object ID is used as an argument to request execution of object reading processing to CAS 400 (S1102).

On the other hand, when the version to be acquired is specified by the argument (when S1102 is Yes), the directory synchronization program 306 converts the path name of the processing target received as the argument into an object ID using the file / directory management information 500 Then, using the object ID and the version received as an argument, the CAS 400 is requested to execute the object reading process (S1103).

CAS 400 executes version list acquisition processing using the object ID and version received from NAS 300 as arguments (S1104). Details of the object reading process will be described later.

Next, the directory synchronization program 306 stores the data obtained as a result of the object reading process (S1104) in the memory 305 of the NAS 300 (S1105).

Next, the directory synchronization program 306 returns the memory address of the data storage destination of the processing result of S1105 to the caller (S1106).

FIG. 12 is an example of a flowchart for explaining details of the rollback processing 1200.

The rollback process 1200 is executed by the CPU 303 of the NAS 300 when the migration process fails.

First, if the rollback target process specified as an argument is the creation of a file or directory (when S1201 is Yes), the rollback program 310 is specified with an argument using the file system program 312. The file or directory having the specified path name is deleted from the file system 318 (S1202).

On the other hand, when the rollback target process specified as an argument is deletion of a file or directory (when S1201 is No and S1203 is Yes), the rollback program 310 uses the file system program 312. A file or directory having the path name specified by the argument is created in the file system 318 (S1204).

Also, if the rollback process specified as an argument is a file or directory move (if S1201 is No, S1203 is No, and S1205 is Yes), the rollback program 310 Using the system program 312, the file system 318 moves the file or directory having the path name after the movement designated by the argument to the path name before the movement designated by the argument (S1206).

Finally, if the rollback process specified as an argument is not a file, directory creation, deletion, or move (if S1201 is No, S1203 is No, and S1205 is No), roll The back program 310 ends without performing any processing.

In the rollback process 1200, when the rollback process is rename, the rollback program 310 uses the file system program 312 and the file system 318 uses the file name of the path name after the rename specified by the argument. Or return the directory to the pathname before the rename specified in the argument.

According to the rollback processing 1200 described above, the NAS 300 that has failed in the migration processing at the time of updating can maintain the consistency of the file systems 318 of the plurality of NAS 300 by restoring the update in the file system 318.

FIG. 13 is an example of a flowchart for explaining details of the directory creation processing 1300.

The directory creation process 1300 is executed by the CPU 303 of the NAS 300 upon receiving a directory creation request from the client PC 201.

First, the file system program 312 of the NAS 300 receives a directory creation request (S1301).

Next, the file system program 312 confirms the lock state 603 by the own NAS of the parent directory of the creation target directory in the directory lock management information 600 (S1302). The procedure of this process is as follows. First, the file system program 312 obtains the path name of the parent directory (one directory above) from the path name of the creation target directory received as an argument. Next, the file system program 312 refers to the file / directory management information 500 and converts the path name of the parent directory into an object ID. Next, the file system program 312 refers to the lock state 603 by the own NAS of the directory lock management information 600 for the object ID of the conversion result, and confirms whether or not the own NAS has acquired the directory lock of the object ID.

If the directory lock of the parent directory has been acquired (if S1302 is Yes), the file system program 312 locks the entry 604 in the directory lock management information 600 having the object ID 602 that matches the object ID of the parent directory. Is increased by one and the process proceeds to S1308 (S1303). The processing after S1308 will be described later.

On the other hand, when the directory lock of the parent directory has not been acquired (when S1302 is No), the file system program 312 executes the following processing from S1304 to S1307.

The file system program 312 calls the directory lock acquisition process of the directory lock program 307 using the object ID of the parent directory as an argument (S1304). The directory lock program 307 requests the CAS 400 to execute the directory lock processing 1800 using the object ID received as an argument as an argument. Details of the directory lock processing 1800 will be described later. Next, when the result of the directory lock processing 1800 is successful, the directory lock program 307 locks the entry 603 having the object ID 602 that matches the object ID received as an argument in the directory lock management information 600 by the own NAS. Is changed to “Lock acquired”. Next, the directory lock program 307 returns the result of the directory lock processing 1800 to the caller.

Next, when the processing result of the directory lock acquisition process is unsuccessful (when S1305 is No), the file system program 312 returns to S1304 and re-executes the directory lock acquisition process of the directory lock program 307. The file system program 312 may set the upper limit number for the re-execution number in advance, and if the failure is repeated more than the upper limit number, the directory creation process may be failed.

On the other hand, when the processing result of the directory lock acquisition process is successful (when S1305 is Yes), the file system program 312 reads the entry having the object ID 602 that matches the object ID of the parent directory in the directory lock management information 600. The lock count 604 is increased by 1 (S1306).

Next, the file system program 312 calls the update list acquisition / application processing 1500 (S1307). Details of the update list acquisition / application process 1500 will be described later.

Next, the file system program 312 creates the directory specified by the argument, and returns the success or failure of creation to the end user (S1308). At this time, the file system program 312 creates an entry of the created directory for the file / directory management information 500 and the directory lock management information 600. In addition, the file system program 312 creates an update list that describes the created directory and the path name of the parent directory. The format of the update list may be any information as long as the creation of the directory can be notified to other NAS.

Next, the file system program 312 calls the directory lock acquisition process of the directory lock program 307 using the object ID of the created directory as an argument (S1309).

Next, the file system program 312 increases the lock count 604 of the entry having the object ID 602 that matches the object ID of the created directory in the directory lock management information 600 by one (S1310).

Next, the file system program 312 calls the migration process of the migration program 309 using the path names of the parent directory, the created directory, and the update list as arguments (S1311). As a result, the file system program 312 transfers the parent directory, the created directory, and the update list to the CAS 400.

Details of the migration process of the migration program 309 are as follows. The migration program 309 refers to the file / directory management information 500 and converts the processing target path name received as an argument into an object ID. Next, the migration program 309 reads the file or directory indicated by the path name received as an argument into the memory 305 using the file system program 312. Next, the migration program 309 requests the CAS 400 to execute the object storage process 1600 using the object ID of the conversion result and the file or directory data read into the memory as arguments. Details of the object storage processing 1600 will be described later. Next, the migration program 309 returns the processing result of the object storage processing 1600 to the caller.

Next, the file system program 312 decrements the lock count 604 of the directory lock management information 600 by 1 for each of the parent directory object ID and the created directory object ID (S1312).

Next, the file system program 312 refers to the directory lock management information 600, and if any of the lock counts 604 is not 0 for the object ID of the parent directory and the object ID of the created directory (when S1313 is No) ), Go to S1315.

On the other hand, the file system program 312 refers to the directory lock management information 600, and when the lock count 604 of at least one of the parent directory object ID and the created directory object ID is 0 (Yes in S1313) The directory lock release process of the directory lock program 307 is called with the object ID as an argument. At this time, if one of the lock counts 604 is 0, the file system program 312 calls the directory lock release process only for the one where the lock count 604 is 0. If both have a lock count 604 of 0, the file system program 312 calls a directory lock release process for both (S1314).

Details of the directory lock release processing of the directory lock program 307 are as follows. The directory lock program 307 requests the CAS 400 to execute the directory unlock processing of the object operation program 407 using the object ID specified by the argument as an argument.

In response, the CAS 400 object operation program 407 executes directory unlock processing. Here, the object operation program 407 acquires the path name of the lock file 802 corresponding to the object ID received by the argument from the lock state management information 800, and deletes the file indicated by this path name from the file system 413. Next, for the object ID received as an argument, the object operation program 407 changes the lock state 803 to unlocked, and initializes information on the lock file 802, the lock time 804, and the relock time 805. Next, the object operation program 407 returns a result to the NAS 300.

When the directory lock program 307 receives the result of the directory unlock processing from the CAS 400, the lock state 603 by the own NAS of the entry corresponding to the object ID received as an argument in the directory lock management information 600 is displayed as “unlocked”. And return the result to the caller.

Next, when there is a next directory creation request (when S1315 is Yes), the file system program 312 returns to S1301.

On the other hand, if there is no next directory creation request (S1315 is No), the file system program 312 ends the directory creation process.

FIG. 14 is an example of a flowchart for explaining details of the directory deletion processing 1400.

The directory deletion process 1400 is executed by the CPU 303 of the NAS 300 when receiving a directory deletion request from the client PC 201.

First, the file system program 312 of the NAS 300 receives a directory deletion request (S1401).

Next, the file system program 312 confirms the lock status of the parent directory of the directory to be deleted by the own NAS (S1402). The procedure of this process is as follows. First, the file system program 312 obtains the path name of the parent directory from the path name of the deletion target directory received as an argument. Next, with reference to the file / directory management information 500, the path name of the parent directory is converted into an object ID. Next, the file system program 312 checks whether or not the lock state 603 by the own NAS of the entry corresponding to the object ID of the parent directory in the directory lock management information 600 has been acquired.

When the directory lock of the parent directory has been acquired (when S1402 is Yes), the file system program 312 in the directory lock management information 600 has the lock count 604 of the entry having the object ID 602 that matches the object ID of the parent directory. Is increased by one and the process proceeds to S1408 (S1403). The processing after S1308 will be described later.

On the other hand, when the directory lock of the parent directory has not been acquired (when S1402 is No), the file system program 312 executes the following processing from S1404 to S1407.

The file system program 312 calls the directory lock acquisition process of the directory lock program 307 using the object ID of the parent directory as an argument (S1304). Details of the directory lock acquisition process are as described above.

Next, when the processing result of the directory lock acquisition process is unsuccessful (when S1405 is No), the file system program 312 returns to S1404 and re-executes the directory lock acquisition process of the directory lock program 307. The file system program 312 may set the upper limit number for the re-execution number in advance, and if the failure is repeated more than the upper limit number, the directory creation process may be failed.

On the other hand, if the processing result of the directory lock acquisition process is successful (when S1405 is Yes), the file system program 312 reads the entry having the object ID 602 that matches the object ID of the parent directory in the directory lock management information 600. The lock count 604 is increased by 1 (S1406).

Next, the file system program 312 calls the update list acquisition / application processing 1500 (S1407). Details of the update list acquisition / application process 1500 will be described later.

Next, the file system program 312 deletes the directory specified by the argument and returns the success or failure of the deletion to the end user (S1408). At this time, the file system program 312 deletes the entry of the deleted directory from the file / directory management information 500 and the directory lock management information 600. In addition, the file system program 312 creates an update list describing the deleted directory and the path name of the parent directory. The format of the update list may be any information as long as the deletion of the directory can be notified to other NAS.

Next, the file system program 312 calls the migration process of the migration program 309 using the path names of the parent directory, the deleted directory, and the update list as arguments (S1409). As a result, the file system program 312 transfers the parent directory, the deleted directory, and the update list to the CAS 400. The details of the migration process are as described above.

Next, the file system program 312 decrements the lock count 604 of the entry having the object ID 602 that matches the object ID of the parent directory in the directory lock management information 600 by one (S1410).

Next, when the lock count 604 of the entry corresponding to the object ID of the parent directory in the directory lock management information 600 is not 0 (when S1411 is No), the file system program 312 proceeds to S1413.

On the other hand, when the lock count 604 of the entry corresponding to the object ID of the parent directory in the directory lock management information 600 is 0 (when S1411 is Yes), the file system program 312 uses the parent directory object ID as an argument. Then, the directory lock release process of the directory lock program 307 is called (S1412). Details of the directory lock release processing are as described above.

Next, when there is a next directory deletion request (S1413 is Yes), the file system program 312 returns to S1401.

On the other hand, when there is no next directory deletion request (S1413 is No), the file system program 312 ends the directory deletion process.

FIG. 15 is an example of a flowchart for explaining the details of the update list acquisition / application process 1500.

The update list acquisition / application process 1500 is executed by the CPU 303 of the NAS 300 in response to a call from the directory creation process 1300 and the directory deletion process. Note that the update list acquisition / application process may be periodically executed regardless of the directory creation process 1300 and the directory deletion process.

First, the update list acquisition / application program 308 acquires the update list from the CAS 400 by requesting the CAS 400 to execute the object reading process 1700 using the object ID and version of the update list as arguments (S1501). . At this time, the update list acquisition / application program 308 acquires the object ID of the update list from the file / directory management information 500. The update list acquisition / application program 308 requests the CAS 400 to execute the object read processing 1700 multiple times when there are multiple versions of the update list that have not been acquired. get. At this time, the update list acquisition / application program 308 records the version of the update list acquired at the time of execution of the previous update list acquisition / application processing 1500 for performance improvement, and acquires it sequentially from the subsequent version. Also good. In addition, when CAS400 provides a process that can acquire multiple versions of one object ID at a time, the update list acquisition / application program 308 uses this process so that only one processing request to CAS400 can be made. Thus, all update lists of unacquired versions may be acquired.

CAS 400 executes the object reading process using the object ID and version specified by the arguments as arguments based on the request from NAS 300, and returns the result to NAS 300 (S1502). Details of the object reading process 1700 of the CAS 400 will be described later.

Next, the update list acquisition / application program 308 sets a synchronization required flag to the file or directory indicated by the path name of the file or directory described in the update list obtained as a result of the object reading process (S1502). (S1503). Specifically, the update list acquisition / application program 308 turns on the synchronization required flag 504 of the entry corresponding to each of all the path names described in the update list in the file / directory management information 500.

Next, the update list acquisition / application program 308, in the file / directory management information 500, when the synchronization required flag 504 of the update target directory to be updated by the own NAS is ON (when S1504 is Yes) The directory synchronization processing 900 is called using the path name of the directory as an argument (S1505). Here, the update target directory is a parent directory of the directory creation process 1300 and the directory deletion process 1400.

On the other hand, in the file / directory management information 500, the update list acquisition / application program 308 executes the update list acquisition / application processing 1500 as it is when the synchronization required flag 504 of the update target directory is OFF (when S1504 is No). finish.

According to the above processing, the NAS 300 sets the synchronization required flag for the object shown in the update list, and executes the directory synchronization processing when the synchronization required flag is set for the object to be updated. Prior to updating the object to be updated, the object to be updated can be matched to the appropriate version in CAS 400.

FIG. 16 is an example of a flowchart for explaining the details of the object saving process 1600.

The object storage process 1600 is executed in the CPU 405 of the CAS 400 in response to a request from the migration process of the migration program 309 of the NAS 300.

First, the object operation program 407 writes the data received from the NAS 300 as a file or directory in the file system 413 (S1601).

Next, the object operation program 407 searches whether the object ID received as an argument from the NAS 300 already exists in the object management information 700 (S1602).

If the object ID specified in the NAS 300 already exists as a result of the search of the object management information 700 (S1603 is Yes), the object operation program 407 displays the version of the data requested to be saved from the NAS 300 by the object management information. The next version of the latest version of the object ID registered in 700 is set (S1604).

If the object ID specified in the NAS 300 does not exist as a result of the search of the object management information 700 (S1603 is No), the object operation program 407 sets the version to 1 (S1604). The version at this time may be any version as long as it can be identified as the first version.

Next, the object operation program 407 adds an entry to the object management information 700. At this time, the object operation program 407 registers the value received as an argument from the NAS 300 in the object ID 701 of the entry, registers the value determined in S1604 or S1605 in the version 702 of the entry, and creates the current time of the entry. Register the path name of the file or directory in which the file system 413 data was stored in S1601 in S1601, and register the processing result in the path name 704 of the entry, and return the processing result to the NAS 300 that is the request source (S1606)

FIG. 17 is an example of a flowchart for explaining details of the object reading process 1700 in the first and third embodiments.

The object read processing 1700 is triggered by a request from one of the CAS data acquisition processing 1100 of the NAS 300 directory synchronization program 306 and the update list acquisition / application processing 1500 of the update list acquisition / application program 308. It is executed in the CPU 405.

First, the object operation program 407 extracts an entry having an object ID 701 that matches the object ID received from the NAS 300 as an argument from the object management information 700 over all versions (S1701).

Next, when the version is specified as an argument from the NAS 300 (when S1702 is Yes), the object operation program 407 searches for the entry of the specified version from the processing result of S1701 (S1704).

On the other hand, if the version is not specified as an argument from the NAS 300 (S1702 is No), the object operation program 407 searches for the latest version entry from the processing result of S1701 (S1705).

Next, the object operation program 407 calls the file system program 408 using the path name 704 of the entry obtained as the processing result of S1704 or S1705 as an argument, and the file or directory data indicated by the path name 704 is read from the file system 413. Read (S1706).

Next, the object operation program 407 returns the read file or directory data to the requesting NAS 300 (S1706).

FIG. 18 is an example of a flowchart for explaining the details of the directory lock processing 1800.

The directory lock processing 1800 is executed by the CPU 405 of the CAS 400 in response to a request from the directory lock acquisition processing of the directory lock program 307 of the NAS 300.

First, the object operation program 407 searches the lock state management information 800 for an entry having an object ID 801 that matches the object ID received as an argument from the NAS 300 (S1801).

Next, when the lock state 803 of the entry obtained as a search result of S1801 is not locked (when S1802 is No), the object operation program 407 executes the processing from S1803 to S1807.

First, the object operation program 407 calls the file system program 408 and creates a lock file in the file system 413 to indicate the lock of the object (S1803). Any method may be used for determining the path name of the lock file. For example, the object operation program 407 saves the object ID received as an argument from the NAS 300 with a character string “.lock” as a file name in the same directory as the object to be locked.

Next, the object operation program 407 updates the lock file 802 of the entry corresponding to the object ID to be processed in the lock state management information 800 with the path name of the file created in S1803 (S1804).

Next, the object operation program 407 updates the lock state 803 of the entry corresponding to the object ID to be processed in the lock state management information 800 to be locked (S1805).

Next, the object operation program 407 updates the lock time 804 of the entry corresponding to the object ID to be processed in the lock state management information 800 to the current time (S1806).

Next, the object operation program 407 returns a lock success to the requesting NAS 300 (S1807).

On the other hand, the lock state 803 of the entry obtained as the search result of S1801 is already locked (when S1802 is Yes), and the elapsed time from the latest lock time based on the entry obtained as the search result of S1801 is the lock time. If it is equal to or greater than the threshold value (when S1808 is Yes), the object operation program 407 executes the following processes of S1809 and S1807. The lock time threshold may be any value. Here, when the relock time 804 is not registered in the entry obtained as the search result of S1801, the object operation program 407 regards the lock time 804 as the latest lock time, and the relock time 804 is registered in the entry. If it is, the relock time 805 is regarded as the latest lock time.

First, the object operation program 407 updates the relock time 805 of the entry corresponding to the object ID to be processed in the lock state management information 800 to the current time (S1809). As a result, the processing target lock thus far expires, and the processing target is subsequently re-locked.

Next, the object operation program 407 returns a lock success to the requesting NAS 300 (S1807).

In addition, the lock state 803 of the entry obtained as the search result of S1801 is locked (when S1802 is Yes), and at least the elapsed time from the latest lock time based on the entry obtained as the search result of S1801 is When it is shorter than the lock time threshold value (when S1808 is No), the object operation program 407 returns a lock failure to the NAS 300 that is the request source (S1810).

According to the above directory lock processing 1800, the NAS 300 can acquire the object of the immediately previous version from the CAS 400 based on the lock time of the object. Further, the CAS 400 can determine the lock expiration based on the latest time among the lock time and the relock time.

In the method of managing directory update transactions with CAS, CAS needs to have a dedicated function for transaction management, and a general public cloud cannot be used.

According to this embodiment, the NAS 300 selects and synchronizes the object versions, so that the directory structure of the file system 318 can be made consistent among a plurality of NAS 300 even if the CAS 400 does not have a special function. Can keep.

Next, Example 2 of the present invention will be described. Hereinafter, differences from the first embodiment will be mainly described, and description of common points with the first embodiment will be omitted or simplified.

In Example 2, when the synchronization target directory is locked by CAS 400, CAS 400 searches for the latest version among the versions older than the lock time.

In Example 2, it is not necessary for the NAS 300 to acquire the version list of the directory to be synchronized from the CAS 400, so the amount of communication can be reduced and performance improvement can be expected. On the other hand, if CAS400 does not have the function of “search for the latest version from versions older than the specified time and send the search result version data back to NAS300”, use Example 2. I can't. Therefore, when the CAS 400 has this function, the second embodiment is used, and when it is not, the second embodiment may be used.

The configuration of the computer system of the second embodiment is the same as the configuration of the computer system of the first embodiment shown in FIG. 2, FIG. 3, and FIG. However, the second embodiment differs from the first embodiment in details of the directory synchronization process shown in FIG. 9, the CAS data acquisition process shown in FIG. 11, and the object reading process shown in FIG. Therefore, in the second embodiment, the directory synchronization process, the CAS data acquisition process, and the object reading process use processes described below.

FIG. 19 is a flowchart for explaining the details of the directory synchronization processing 1900 in the second embodiment.

The directory synchronization processing 1900 is triggered by either the call of the update list acquisition / application processing 1500 or the access by the end user of the NAS 300 to the directory for which the synchronization required flag 504 of the file / directory management information 500 is ON. It is executed by CPU303 of NAS300.

First, the directory synchronization program 306 calls the CAS data acquisition process 2000 using the path name to be processed received as an argument as an argument (S1901). As a result of the CAS data acquisition process 2000, the directory synchronization program 306 obtains directory data and version.

Next, the directory synchronization program 306 executes a directory reading process on the NAS using the path name of the processing target received as an argument, and reads the processing target directory stored in the file system 318 by the NAS 300 (S1902). The directory reading process on the NAS reads the directory indicated by the path name received as an argument from the file system 318 by calling the file system program 312.

Next, the directory synchronization program 306 compares the directory obtained as a result of the CAS data acquisition process (S1901) with the directory obtained as a result of the NAS directory read process (S1902), and obtains it from CAS400. A directory entry created or deleted in the directory is extracted, and the same creation or deletion is performed in the corresponding directory in the file system 318 of the NAS 300 (S1903). In order to perform this creation and deletion, the directory synchronization program 306 calls the file system program 312.

Next, when the version obtained as a result of the CAS data acquisition process (S1901) is the latest version (when S1904 is Yes), the directory synchronization program 306 includes the entries in the file / directory management information 500. The synchronization required flag 504 of the entry having the path name 501 that matches the processing target path name received as an argument is changed to OFF (S1905).

On the other hand, if the version obtained as a result of the data acquisition process on CAS (S1901) is not the latest version (if S1904 is No), the directory synchronization program 306 uses the arguments in the file / directory management information 500 entries. The synchronization necessity flag 504 of the entry having the path name 501 that matches the path name to be processed received as is kept ON (S1906).

FIG. 20 is an example of a flowchart for explaining details of the on-CAS data acquisition processing 2000 according to the second embodiment.

The CAS data acquisition process 2000 is executed by the CPU 303 of the NAS 300 in response to a call from the directory synchronization process 900 in the second embodiment.

First, the directory synchronization program 306 refers to the file / directory management information 500, converts the path name of the processing target received as an argument into an object ID, and lock confirmation processing to the CAS 400 using the object ID of this conversion result as an argument Is requested to execute (S2001).

CAS400 executes lock confirmation processing based on the request from NAS300 (S2002). Details of the CAS 400 lock confirmation processing are as described in the first embodiment.

When the processing result of the lock confirmation processing (S2002) is not locked (when S2003 is No), the directory synchronization program 306 reads the object 2700 into the CAS 400 using the object ID as an argument without specifying the time. Is requested to execute (S2004).

On the other hand, when the processing result of the lock confirmation processing (S2002) has been locked (when S2003 is Yes), the directory synchronization program 306 executes S2005 and S2007.

The directory synchronization program 306 requests the CAS 400 to execute the lock time acquisition process using the object ID as an argument (S2005). This object ID is the same as the object ID used as an argument in S2001.

CAS 400 executes lock time acquisition processing based on a request from NAS 300 (S2006). Details of the lock time acquisition processing of the CAS 400 are as described in the first embodiment.

Next, the directory synchronization program 306 requests the CAS 400 to execute the object reading process 2100 with the lock time obtained as a result of the lock time acquisition process (S2006) and the object ID as arguments (S2007). This object ID is the same as the object ID used as an argument in S2001.

CAS 400 executes object reading processing 2100 according to the request from NAS 300 (S2008). Details of the object reading process 2100 will be described later.

Next, the directory synchronization program 306 stores the data obtained as a result of the object reading process (S2008) in the memory 305 of the NAS 300 (S2009).

Next, the directory synchronization program 306 returns the address in the memory 305 that stores the data in S2009 and the directory version acquired from the CAS 400 to the caller (S2010). Note that this version may be only information indicating whether or not the latest version has been acquired.

According to the above CAS data acquisition process 2000, the NAS 300 can acquire the object of the version immediately before the update from the CAS 400 by sending a request including the lock time to the CAS 400.

FIG. 21 is an example of a flowchart for explaining details of the object reading process 2100 according to the second embodiment.

The object reading process 2100 is triggered by a request from one of the CAS data acquisition process 2000 of the NAS 300 directory synchronization program 306 and the update list acquisition / application process 1500 of the update list acquisition / application program 308. It is executed in the CPU 405.

First, the object operation program 407 extracts an entry having an object ID 701 that matches the object ID received as an argument from the NAS 300 in all object management information 700 over all versions (S2101).

Next, when a version is specified as an argument from the NAS 300 (when S2102 is Yes), the object operation program 407 searches for an entry of the specified version from the processing result of S2101 (S2103).

On the other hand, when the version is not specified as an argument from the NAS 300 (when S1702 is No) and the time is specified as an argument from the NAS 300 (when S2104 is Yes), the object operation program 407 performs the process of S2101. Based on the result, an entry having a creation time 703 older than the specified time and having the latest version 702 is searched (S2105).

If the version is not specified as an argument from the NAS 300 (when S1702 is No) and the time is not specified as an argument from the NAS 300 (when S2104 is No), the object operation program 407 performs the processing of S2101. From the result, an entry having the latest version 702 is searched (S2106).

Next, the object operation program 407 calls the file system program 408 to read from the file system 413 the file or directory data indicated by the entry path name 704 obtained as a search result of S2103, S2105, or S2106 (S2107). ).

Next, the object operation program 407 returns the data read in S2107 to the NAS 300 that is the request source (S2108).

According to the present embodiment, when the update target object of the NAS 300 is locked, the CAS 400 identifies the object of the version immediately before the update based on the lock time, and transmits it to the NAS 300. Can be synchronized with the previous version.

Next, Example 3 of the present invention will be described. Hereinafter, differences from the first embodiment will be mainly described, and description of common points with the first embodiment will be omitted or simplified.

In the third embodiment, when a plurality of directories are acquired, a plurality of directories are updated, and a failure occurs, the NAS 300 unlocks the directory to be synchronized if one of the directories is unlocked. If not, sync to a newer version than the lock time. For example, when moving the target directory from below the parent directory A to a different directory B, first lock the two directories A and B, then move the target directory, and then move 2 on the CAS400. Update two directories A and B, and finally unlock the two directories A and B. In this case, Example 3 is useful. When acquiring locks of a plurality of directories, a directory A having a child directory B may be deleted.

When one of the two directories A and B locked at the same time is unlocked, the unlocked directory is synchronized with the moved version, as in the directory synchronization process 1900 described above. You should avoid synchronizing locked directories with the previous version. At this time, in the third embodiment, when at least one of the plurality of directories locked together is unlocked, the NAS 300 can synchronize all of the plurality of directories with the locked version, that is, the updated version. .

Therefore, when a process of simultaneously locking a plurality of directories, updating a plurality of directories on the CAS 400, and unlocking these directories is employed, the third embodiment may be used. On the other hand, when such processing is not employed, the first embodiment or the second embodiment may be used.

In addition, Example 3 may be used in combination with Example 2.

The configuration of the computer system of the third embodiment is the same as the configuration of the computer system of the first embodiment shown in FIG. 2, FIG. 3, and FIG. However, the third embodiment differs from the first embodiment in the details of the configuration of the lock state management information shown in FIG. 8, the synchronization version confirmation process shown in FIG. 10, and the directory lock process shown in FIG. Therefore, in the third embodiment, the lock state management information, the synchronization version determination process, and the directory lock process use processes described below.

FIG. 22 shows a configuration example of the lock state management information 2200 in the CAS 400 of the third embodiment.

The lock state management information 2200 includes an object ID 801, a lock file 802, a lock state 803, a lock time 804, a relock time 805, and a related lock target 2201 as one entry.

The object ID 801, the lock file 802, the lock state 803, the lock time 804, and the relock time 805 are the same as the lock state management information 800 in the first and second embodiments.

The related lock target 2201 indicates the object ID of the object that the NAS 300 that locks the object indicated by the object ID 801 of the entry is simultaneously locking and updating. This information is designated by the NAS 300 as an argument for directory lock processing. The related lock target 2201 is set only when one NAS 300 simultaneously locks a plurality of objects. That is, an entry in which the lock state 803 is locked and the related lock target 2201 is not set indicates that there is no directory that is simultaneously locked and updated. For example, in the example of FIG. 22, an entry whose object ID 801 is pqr indicates that the object is locked, but there is no directory that is simultaneously locked and updated. The related directory 2201 may set two or more object IDs.

FIG. 23 is an example of a flowchart for explaining the details of the directory lock processing 2300.

The directory lock process 2300 is executed in the CPU 405 of the CAS 400 in response to a request from the directory lock acquisition process of the directory lock program 307 of the NAS 300.

First, the object operation program 407 searches the lock state management information 800 for an entry having an object ID 801 that matches the object ID received as an argument from the NAS 300 (S2301).

Next, when the lock state 803 of the entry obtained as the search result of S2301 is not locked (when S2302 is No), the object operation program 407 executes the following processing from S2303 to S2308.

First, the object operation program 407 calls the file system program 408 and creates a lock file for indicating lock to the file system 413 (S2303). The method for determining the path name of the lock file may be any method as in the first embodiment.

Next, the object operation program 407 updates the lock file 802 of the entry corresponding to the object ID to be processed in the lock state management information 800 with the path name of the lock file created in S2303 (S2304).

Next, the object operation program 407 updates the lock state 803 of the entry corresponding to the object ID to be processed in the lock state management information 800 to be locked (S2305).

Next, the object operation program 407 updates the lock time 804 of the entry corresponding to the object ID to be processed in the lock state management information 800 to the current time (S1806).

Next, the object operation program 407 updates the related lock target 2201 of the entry corresponding to the processing target object ID 801 in the lock state management information 800 to the information received as an argument from the NAS 300 (S1807). That is, when the NAS 300 does not specify the related lock target, the object operation program 407 does not set information in the related lock target 2201 of the entry. On the other hand, when the NAS 300 specifies the related lock target, the object operation program 407 sets the specified information in the related lock target 2201 of the entry.

Next, the object operation program 407 returns a lock success to the requesting NAS 300 (S2308).

On the other hand, the entry lock state 803 obtained as the search result of S2301 is already locked (when S1802 is Yes), and the elapsed time and the relock time from the lock time 804 of the entry obtained as the search result of S2301 When both the elapsed times from 805 are equal to or greater than the lock time threshold value (when S2309 is Yes), the object operation program 407 executes the processing of S2310, S2307, and S2308. This threshold value may be any value.

First, the object operation program 407 updates the relock time 805 of the entry corresponding to the object ID to be processed in the lock state management information 800 to the current time (S2310).

Next, the object operation program 407 updates the related lock target 2201 of the entry corresponding to the object ID to be processed in the lock state management information 800 to the information received as an argument from the NAS 300 (S2307). As a result, when the NAS 300 has not designated the related lock target, the object operation program 407 changes to a state in which no information is set in the related lock target 2201 of the entry. When the NAS 300 designates the related lock target, the object operation program 407 updates the related lock target 2201 of the entry to the designated information.

Next, the object operation program 407 returns a lock success to the requesting NAS 300 (S2308).

In addition, the entry lock state 803 obtained as a search result of S2301 is locked (when S1802 is Yes), and either the lock time 804 or the relock time 805 of the entry obtained as a search result of S2301 Alternatively, when the elapsed time from both is shorter than the threshold value (when S2309 is No), the object operation program 407 returns a lock failure to the NAS 300 that is the request source (S2311).

FIG. 24 is an example of a flowchart for explaining details of the synchronization version determination process 2400 in the third embodiment.

The synchronization version confirmation process 2400 is executed by the CPU 303 of the NAS 300 in response to a call from the directory synchronization process 900.

First, the directory synchronization program 306 refers to the file / directory management information 500, converts the path name of the processing target received as an argument into an object ID, and lock confirmation processing to the CAS 400 using the object ID of this conversion result as an argument Is requested to execute (S2401).

CAS 400 executes lock processing confirmation processing using the object ID received from NAS 300 as an argument (S2402). The details of the lock confirmation processing are as described in the first embodiment.

If the result of the lock confirmation process (S2402) is not locked (if S2403 is No), the directory synchronization program 306 determines the result of the synchronization version confirmation process 2400 as the latest version and returns it to the caller (S2404).

When the processing result of the lock confirmation processing (S2402) has been locked (when S2403 is Yes), the directory synchronization program 306 executes the processing after S2405.

First, the directory synchronization program 306 requests the CAS 400 to execute the lock time acquisition process using the object ID corresponding to the processing target path name received as an argument (S2405).

CAS 400 executes the lock time acquisition process using the object ID received from NAS 300 as an argument (S2406). The details of the lock time acquisition processing are as described in the first embodiment.

Next, the directory synchronization program 306 requests the CAS 400 to execute related lock target acquisition processing using the object ID corresponding to the processing target path name received as an argument (S2407).

CAS 400 executes related lock target acquisition processing using the object ID received from NAS 300 as an argument (S2408). The related lock target acquisition processing returns the related lock target 2201 of the entry having the object ID 801 that matches the object ID received as an argument in the lock state management information 2200 to the NAS 300.

Next, the directory synchronization program 306 executes the following processes from S2409 to S2413 for all object IDs obtained as a result of the related lock target acquisition process (S2408).

First, the directory synchronization program 306 selects one of the object IDs obtained as a result of the related lock target acquisition process (S2408) (S2409), and executes the lock confirmation process to the CAS 400 using the selected object ID as an argument. Request (S2410).

CAS 400 executes lock processing confirmation processing using the object ID received from NAS 300 as an argument (S2411). The details of the lock confirmation processing are as described in the first embodiment.

If the result of the lock confirmation process (S2411) is not locked (if S2412 is No), the directory synchronization program 306 determines the result of the synchronization version confirmation process 2400 as the latest version and returns it to the caller (S2404).

When the processing result of the lock confirmation processing (S2402) is locked (when S2412 is Yes), all object IDs are selected from the object IDs obtained as the processing result of the related lock target acquisition processing (S2408). Up to step S2409, the next object ID is selected, and steps S2410, S2411, and S2412 are executed.

If all the object IDs obtained as a result of the related lock target acquisition process (S2408) are locked (if S2412 is Yes), the directory synchronization program In step S2414, 306 requests the CAS 400 to execute the version list acquisition process of the processing target directory, using the object ID corresponding to the processing target path name received as the argument.

CAS 400 executes version list acquisition processing using the object ID received from NAS 300 as an argument (S2415). Details of the version list processing are as described in the first embodiment.

Next, the directory synchronization program 306 creates the creation time of each version included in the version list acquired as the processing result of the version list acquisition processing (S2415), the lock time acquired as the processing result of the lock time acquisition processing (S2406), , And the latest version among the versions having the creation time older than the lock time is searched from the version list. The directory synchronization program 306 determines the result of the synchronization version determination process 2400 as the version obtained as the search result, and returns it to the caller (S2416).

According to the synchronous version confirmation processing 2400 described above, when the NAS 300 fails to unlock all the objects in the update that locks the plurality of objects, the other NAS 300 considers that the update has not been completed, and the file By synchronizing a plurality of objects in the system 318 to the version immediately before the update, the consistency of the file systems 318 of the plurality of NAS 300 can be maintained. In addition, if the unlocking of some of the plurality of objects in the update fails, the other NAS 300 considers that the update has been completed, and synchronizes the plurality of objects in the file system 318 with the latest version. The consistency of the file system 318 of the NAS 300 can be maintained. Further, when the NAS 300 includes other objects that need to be locked in the object lock request, the CAS 400 can recognize a plurality of objects that are locked together. Further, when the CAS 400 includes information on another object locked together in the information indicating the lock of the object, the NAS 300 can acquire information on a plurality of objects locked together from the CAS 400.

The terms for expressing the present invention will be described. The update request may be a request for an update operation from the client PC 201. The first lock time may be a lock time. The second lock time may be a relock time. The update information may be an update list. The synchronization information may be a synchronization required flag. The version information may be a version list. The related object may be an object shown in the related lock target 2201 corresponding to the specific object. The controller may be the NAS controller 301. The storage device may be the storage device 322. The specific object lock information may be a lock state 803 corresponding to the specific object. The related object lock information may be a lock state 803 corresponding to the related object.

As mentioned above, although embodiment of this invention was described, this is an illustration for description of this invention, Comprising: It is not the meaning which limits the scope of the present invention to the said structure. The present invention can be implemented in various other forms.

201 ... Client PC, 202 ... Network, 300 ... NAS, 301 ... NAS Controller, 302 ... I / F, 303 ... CPU, 304 ... Network I / F, 305 ... Memory, 322 ... Storage device, 400 ... CAS, 401 ... CAS controller, 402 ... Storage device, 403 ... Network I / F, 404 ... I / F, 405 ... CPU, 406 ... Memory

Claims (15)

1. An object storage device;
   A storage device connected to the object storage device;
   With
   When the storage apparatus receives an update request for requesting an update of a specific object in the storage apparatus, the storage apparatus requests the object storage apparatus to lock the specific object in the object storage apparatus, and the specific object in the storage apparatus Update the specific object, send the updated specific object to the object storage device, request the object storage device to release the lock of the specific object,
   The object storage device stores the specific object for each version,
   When the storage device refers to a specific object in the storage device, the storage device determines whether or not the specific object in the object storage device is locked,
   When it is determined that the specific object in the object storage device is locked, the storage device acquires the specific object of the immediately previous version that is the version immediately before the determined lock from the object storage device, and A specific object in the storage device is matched with the specific object of the previous version,
   Storage system.
2. When it is determined that the specific object in the object storage device is not locked, the storage device acquires the latest version of the specific object from the object storage device, and the specific object in the storage device of the latest version is updated. Match a specific object,
   The storage system according to claim 1.
3. When it is determined that the specific object in the object storage device is locked, the storage device acquires a first lock time that is a time when the specific object is locked from the object storage device, and Obtaining the specific object of the immediately previous version from the object storage device based on one lock time;
   The storage system according to claim 2.
4. The object storage device stores update information indicating an updated object in the object storage device,
   When the storage device receives the update request, the storage device acquires unacquired update information from the object storage device, and indicates that synchronization is required for the object indicated in the acquired update information. When information is set and synchronization information is set for the specific object, a process for referring to the specific object in the storage device is executed.
   The storage system according to claim 3.
5. When the storage device matches the specific object in the storage device with the specific object of the latest version, the synchronization information for the specific object is released,
   The storage device maintains synchronization information for the specific object when the specific object in the storage device matches the specific object of the immediately previous version.
   The storage system according to claim 4.
6. When the object storage device is requested to lock the specific object from the storage device, the object storage device determines whether the specific object in the object storage device is locked,
   When it is determined that the specific object in the object storage device is not locked, the object storage device locks the specific object and sets the current time as the first lock time for the specific object. , Storing the first lock time while the specific object is locked,
   If it is determined that the specific object is locked, the object storage device determines whether the elapsed time from the latest lock time stored for the specific object is equal to or greater than a preset upper limit time. Determine whether
   When it is determined that the elapsed time is equal to or greater than the upper limit time, the object storage device sets the current time as the second lock time for the specific object, and the first time while the specific object is locked. Store the second lock time,
   The storage system according to claim 5.
7. If the storage device fails to reflect the updated specific object to the object storage device after updating the specific object in the storage device based on the update request, the specific object in the storage device Undo updates for,
   The storage system according to claim 6.
8. The object storage device stores version information indicating the creation time of each of a plurality of versions of the specific object,
   When it is determined that the specific object in the object storage device is locked, the storage device acquires the version information from the object storage device, and based on the first lock time and the version information, A version is specified, and the specific object of the immediately previous version is acquired from the object storage device;
   The storage system according to claim 7.
9. The object storage device stores version information indicating the creation time of each of a plurality of versions of the specific object,
   When it is determined that the specific object in the object storage device is locked, the storage device transmits a request indicating the specific object and the lock time to the object storage device,
   The object storage device specifies the immediately previous version based on the first lock time and the version information, and transmits the specific object of the immediately previous version to the storage device.
   The storage system according to claim 7.
10. When the update includes an update of a related object related to the specific object, the storage apparatus sends a lock of the specific object in the object storage apparatus and a lock of the related object in the object storage apparatus to the object storage apparatus. To update the specific object and the related object in the storage device, send the updated specific object and the updated related object to the object storage device, and release the lock of the specific object and the related object. Requesting the object storage device to release the lock of
    When the storage device refers to a specific object in the storage device, it determines whether both the specific object in the object storage device and the related object in the object storage device are locked,
    When it is determined that both the specific object in the object storage device and the related object in the object storage device are locked, the storage device displays object information indicating the state of the specific object in the object storage device. Obtaining the specific object of the immediately previous version from the object storage device based on the specific object information, and matching the specific object in the storage device with the specific object of the immediately previous version;
    The storage system according to claim 7.
11. When it is determined that at least one of the specific object in the object storage device and the related object in the object storage device is not locked, the storage device acquires the latest version of the specific object from the object storage device, A specific object in the storage device is matched with the specific object of the latest version;
    The storage system according to claim 10.
12. A request for a lock of a specific object in the object storage device and a lock of a related object in the object storage device indicates an association between the specific object and the related object;
    The storage system according to claim 11.
13. When the storage device refers to a specific object in the storage device, the storage device acquires from the object storage device specific object lock information indicating whether or not the specific object in the object storage device is locked,
    When the specific object lock information indicates that a specific object in the object storage device is locked, the storage device indicates whether or not the related object in the object storage device is locked. Obtaining information from the object storage device;
    The storage system according to claim 11.
14. A storage device;
    A controller connected to the storage device and the object storage device;
    With
    When the controller receives an update request for requesting an update of a specific object in the storage device, the controller requests the object storage device to lock the specific object in the object storage device, and sets the specific object in the storage device. Update, send the updated specific object to the object storage device, request the object storage device to release the lock of the specific object, and send the specific object to the object storage device for each version. Stored,
    When the controller refers to a specific object in the storage device, the controller determines whether or not the specific object in the object storage device is locked,
    When it is determined that the specific object in the object storage device is locked, the controller acquires from the object storage device the specific object of the immediately previous version that is the version immediately before the determined lock, and stores the stored object. Match a specific object in the device with the specific object of the previous version,
    Storage device.
15. A storage system control method including a storage device and an object storage device,
    When the storage apparatus receives an update request for requesting an update of a specific object in the storage apparatus, the storage apparatus requests the object storage apparatus to lock the specific object in the object storage apparatus, and specifies the specific object in the storage apparatus. Update, send the updated specific object to the object storage device, request the object storage device to release the lock of the specific object, and send the specific object to the object storage device for each version. Stored,
    When referring to a specific object in the storage device, determine whether the specific object is locked,
    When it is determined that the specific object is locked, the specific object of the immediately previous version that is the version immediately before the determined lock is acquired from the object storage device, and the specific object in the storage device is acquired as the immediately previous version. Match a specific object of
    Control method.

Images