Storage system, and storage control method

Abstract

To provide a high-performance storage system.SOLUTION: A non-volatile storage has a persistence area and a cache data log area. A memory has a cache data log area. A processor stores data for the write request in the cache data log area, and responds to the write requester by storing the log header that has the sequence number and the data stored in memory in the cache data log area. The processor registers the sequence number of the log header in the invalidation table, destages the data stored in memory to the persistence area, creates a log header that has a sequence number, and registers the sequence number in the invalidation table. When collecting the cache data log area by garbage collection, the processor deletes the log header and corresponding data that have a sequence number older than the sequence number registered in the invalidation table from the cache data log area to release the storage space.SELECTED DRAWING: Figure 4

Description

[Technical Field]

[0001] The present invention relates to a storage system and a storage control method. [Background technology]

[0002] Conventionally, a technology for realizing a storage system that combines high performance and reliability is described in Japanese Patent Laid-Open No. 2023-152247 (Patent Document 1). This publication describes the following: "A storage system including a non-volatile storage device, a storage controller that controls reading and writing to the storage device, and a memory, wherein the storage controller generates a log and stores it in a log memory when reading and writing, writes the log stored in the memory to the storage device, recovers the capacity of the memory storage area that stored the log written to the storage device, and recovers free space in the memory by using a base image backup method that writes to the storage device in units of storage areas each having multiple logs to recover the free space, and a garbage collection method that writes to the storage device in units of logs to recover the free space." [Prior art documents] [Patent documents]

[0003] [Patent Document 1] Japanese Patent Application Publication No. 2023-152247 Summary of the Invention [Problem to be solved by the invention]

[0004] The above technology writes cache data logs to the log area on the storage device in an append-write format, and uses a garbage collection method to reclaim free space by excluding invalid logs and copying valid old logs to the end of the log area as new logs.However, each time a log is overwritten or deleted from the cache by asynchronous destaging, a search is performed to see if there are any logs that can be invalidated, which is costly.

[0005] Therefore, the present invention aims to improve performance by performing high-speed invalidation determination without searching for whether each log can be invalidated. [Means for solving the problem]

[0006] In order to achieve the above object, one representative storage system of the present invention is a storage system comprising a non-volatile storage device, a processor that operates as a storage controller that processes reads and writes to the storage device, and a memory, wherein the storage device has a persistent area that destages data and stores it persistently, and a cache data log area that stores a cache data log to make it non-volatile, the memory has a cache data area, and when the processor receives a write request, it stores data related to the write request in the cache data area provided in the memory, creates a log header having a sequence number related to the memory storage of the data, and the data stored in memory is stored in a cache data log area of ​​the storage device to respond to the source of the write request, the sequence number of the created log header is registered in an invalidation table, the data stored in the memory is destaged to a permanent area of ​​the storage device, a log header having the sequence number of the destage is created and the sequence number is registered in the invalidation table, and when the cache data log area of ​​the storage device is recovered using a garbage collection method, the log header having a sequence number older than the sequence number registered in the invalidation table and the data related to the log header are deleted from the cache data log area to free up the storage area. Furthermore, one representative storage control method of the present invention is a storage control method for controlling a storage system comprising a non-volatile storage device, a processor operating as a storage controller for processing reads and writes to the storage device, and a memory, wherein the storage device has a persistent area for destaging data and storing it persistently, and a cache data log area for storing a cache data log to make it non-volatile, the memory has a cache data area, and when the processor receives a write request, it stores data related to the write request in the cache data area provided in the memory, creates a log header having a sequence number for storing the data in memory, and the data stored in the memory is stored in a cache data log area of ​​the storage device to respond to the source of the write request, the sequence number of the created log header is registered in an invalidation table, the data stored in the memory is destaged to a permanent area of ​​the storage device, a log header having the sequence number of the destage is created and the sequence number is registered in the invalidation table, and when the cache data log area of ​​the storage device is collected using a garbage collection method, a log header having a sequence number older than the sequence number registered in the invalidation table and data related to the log header are deleted from the cache data log area to free up storage area. [Effects of the Invention]

[0007] According to the present invention, a high-performance storage system can be realized. Problems, configurations, and effects other than those described above will become apparent from the following description of the embodiment. [Brief explanation of the drawings]

[0008] [Figure 1] 1 is a diagram illustrating the configuration of a storage system according to a first embodiment of the present invention. [Figure 2] FIG. 1 illustrates an example of the physical configuration of a storage node. [Figure 3] FIG. 1 is a diagram showing an example of a logical configuration of a storage node. [Figure 4] FIG. 1 is a diagram illustrating an overview of the disclosed storage system and storage control method. [Figure 5] Overview of the compression function [Figure 6] FIG. 1 is a diagram showing an example of a memory configuration diagram. [Figure 7] FIG. 1 is a diagram showing an example of a configuration diagram of a storage device; [Figure 8] A diagram showing an example of the software module structure of a storage controller. [Figure 9] Diagram showing the structure of a log header [Figure 10] Diagram showing the structure of the invalidation table [Figure 11] Read processing flowchart [Figure 12] Write processing flowchart [Figure 13] Asynchronous destage processing flowchart [Figure 14] Cache data update process flowchart [Figure 15] Log creation process flowchart [Figure 16] Confirmation process flowchart [Figure 17] Log backup process flowchart [Figure 18] Flowchart of valid / invalid management process [Figure 19] Flowchart of invalidation table registration process [Figure 20] Cache Data Log Garbage Collection Process Flowchart [Figure 21] Flowchart of re-logging process for each cache segment [Figure 22] FIG. 10 is a diagram showing the structure of a revocation table according to the second embodiment; [Figure 23] Flowchart of invalidation table registration process according to the second embodiment [Figure 24] FIG. 10 is a diagram showing an example of a memory configuration diagram according to a third embodiment. [Figure 25] FIG. 10 is a diagram showing the structure of a coarse-grained invalidation table according to the third embodiment; [Figure 26] FIG. 10 is a diagram showing the structure of a fine-grained invalidation table according to the third embodiment; [Figure 27] Flowchart of invalidation table registration process according to the third embodiment [Figure 28] Flowchart of re-logging process for each cache segment in the third embodiment [Figure 29] FIG. 13 is a diagram showing the structure of a coarse-grained invalidation table according to the fourth embodiment; DETAILED DESCRIPTION OF THE INVENTION

[0009] Hereinafter, an embodiment of the present invention will be described with reference to the drawings. The embodiment relates to a storage system including a plurality of storage nodes in which one or more SDS (Software Defined Storage) are implemented, for example. An embodiment will be described in detail below. [Example]

[0010] 1 is an explanatory diagram of a storage system of Example 1. The storage system 100 includes one or more host devices 101, one or more storage nodes 103, and a management node 104. The host devices 101, the storage nodes 103, and the management node 104 are connected to each other via a network 102.

[0011] The host device 101 is a general-purpose computer used by a user. The host device 101 may be a physical computer or a virtual computer running on a physical computer. The host device 101 transmits a read request or a write request to the storage node 103 in response to, for example, a user operation or a request from an application program. A "read request or a write request" is referred to as an "I / O request."

[0012] The network 102 may be, for example, a storage area network (SAN) or a local area network (LAN). The connection standard of the network 102 may be, for example, Fibre Channel or Ethernet (registered trademark).

[0013] The storage node 103 is a computer having a storage device. The storage node 103 may be, for example, a general-purpose server. The storage node 103 provides the host device 101 with a storage area for reading and writing data.

[0014] The management node 104 is a computer used by an administrator to manage the entire storage system 100. The management node 104 manages two or more storage nodes as a "cluster." Note that there may be one or more clusters within the storage system 100. The storage system 100 may be on-premise, cloud-based, or a hybrid of these. The network 102 may be, for example, a virtual network on the cloud, and the storage node 103 may be, for example, a virtual server on the cloud.

[0015] 2 is a diagram showing an example of the physical configuration of the storage node 103. The storage node 103 includes a CPU (Central Processing Unit) 1031, a memory 1032, one or more storage devices 1033, and a NIC (Network Interface Card) 1034.

[0016] The CPU 1031 is a processor device that controls the operation of the storage node. The memory 1032 is a semiconductor memory that temporarily stores application programs and data. The memory 1032 may be, for example, a static RAM (random access memory) or a dynamic RAM (DRAM). The CPU 1031 controls the operation of the storage node by executing application programs stored in the memory 1032.

[0017] The storage device 1033 is a non-volatile storage device. The storage device 1033 provides a physical storage area for reading or writing data in response to an I / O request from the host device 101. The storage device 1033 may be, for example, a hard disk drive (HDD), a solid state drive (SSD), or a non-volatile memory express (NVMe) drive.

[0018] The NIC 1034 is an interface that enables the storage node 103 to communicate with the host device 101, other storage nodes 103, or the management node 104 via the network 102. The NIC 1034 may be, for example, an FC card in addition to a NIC. The NIC 1034 controls protocols during communication with the host device 101, other storage nodes 103, or the management node 104.

[0019] 3 is a diagram showing an example of the logical configuration of the storage node 103. The storage node 103 includes a front-end driver 1051, one or more storage controllers 1052, a data protection controller 1053, and a back-end driver 1054.

[0020] The front-end driver 1051 is software that controls the NIC 1034 and has the function of providing the CPU 1031 with an abstracted interface to the storage controller 1052 when communicating with the host device 101, other storage nodes 103, or the management node 104.

[0021] The back-end driver 1054 is software that controls each storage device 1033 in its own storage node 103 and has the function of providing the CPU 1031 with an abstracted interface for communication with each storage device 1033 .

[0022] The storage controller 1052 is software that functions as a controller for the SDS. The storage controller 1052 accepts I / O requests from the host device 101 and issues I / O commands corresponding to the I / O requests to the data protection controller 1053. The storage controller 1052 also has a logical volume configuration function. The logical volume configuration function associates logical chunks configured by the data protection controller 1053 with logical volumes to be provided to the host. The association may be, for example, a straight mapping method (a one-to-one correspondence between logical chunks and logical volumes, with the addresses of the logical chunks and the addresses of the logical volumes being the same) or a virtual volume function (Thin Provisioning) method (dividing the logical chunks and logical volumes into small-sized areas (pages), and associating the addresses of the logical chunks and logical volumes on a page-by-page basis).

[0023] In the first embodiment, a storage controller 1052 on a certain storage node 103 is managed as a storage controller group 1055 that configures a redundant configuration together with one or more storage controllers 1052 on other storage nodes 103. In the storage controller group 1055, one storage controller 1052 is set to a state where it can accept I / O requests from the host device 101 (a current system state, called active). In the storage controller group 1055, an inactive storage controller 1052 is set to a state where it cannot accept I / O requests from the host device 101 (a standby system state, called standby). In FIG. 3, for example, a storage controller group 1055A is configured with a storage controller 1052A1 on storage node 103A as active and a storage controller 1052B1 on storage node 103B as standby.

[0024] In the storage controller group 1055, if a failure occurs in the storage node 103 in which the storage controller 1052 set as active is located, the status of the storage controller 1052 that was set as standby until then is switched to active. As a result, if the storage controller 1052 set as active becomes unable to operate, the I / O processing that was being executed by the storage controller 1052 can be taken over by the storage controller 1052 set as standby.

[0025] The data protection controller 1053 is software that allocates physical storage areas provided by storage devices 1033 within its own storage node 103 or other storage nodes 103 to each storage controller group 1055, and has the function of reading or writing specified data to the corresponding storage device 1033 in accordance with I / O commands given by the storage controller 1052.

[0026] FIG. 4 is a diagram illustrating an overview of the disclosed storage system and storage control method. The storage controller 1052 updates cache data for processing I / O requests from the host device 101 and various other processes. At this time, the cache data in the cache data area 10321 of the memory 1032 is updated, and a log is created in the cache data log buffer 10322. The log is then stored in the cache data log area 10332 of the storage device 1033 to be made nonvolatile. The log is made up of the updated cache data itself (log data) and a log header 103231, and is information indicating how the cache data in memory was updated. As shown in FIG. 9, the log header 103231 contains information indicating the update address, update size, and the order of updates. Note that in cases such as asynchronous destaging, which will be described later, where the update involves writing the data to the permanent area 10331 and deleting the cache data from the cache data area 10321, the log may consist of only the log header 103231. Furthermore, the log is made nonvolatile in the cache data log area 10332 , and the log header 103231 is stored in the cache data log header management list 10323 on the memory 1032 .

[0027] To avoid confusion in the following explanation, let us clarify the difference between destaging data and storing logs in the cache data log area. Destaging is the process of writing dirty data from the cache to a persistent area in the storage device, which is the final storage medium. Data is stored in the storage device using the storage functions provided by the storage system (mainly the controller) to enhance data protection, capacity efficiency, I / O performance, and other aspects. For example, data is protected using a method such as RAID6, in which case parity data is generated during the destaging process and is also written to the drive. Once destaging is complete, the data in memory and the data in the storage device are consistent (clean), so it is acceptable for that data to be lost from memory.

[0028] Furthermore, the cache data area 10321 is divided into multiple cache segments 103211. Asynchronous destaging is performed when cache data has been updated in the cache segment 103211 but the data has not been updated (is dirty) in the permanent area 10331 on the storage device 1033. Asynchronous destaging is an operation that writes data from the cache segment 103211 to the permanent area 10331 asynchronously with an I / O request.

[0029] The log in the cache data log buffer 10322 is written in an append format to the cache data log area 10332 in the storage device 1033. This writing may be done immediately or asynchronously.

[0030] Because of the append writes, the free space in the cache data log area 10332 on each storage device 1033 gradually decreases until it becomes impossible to write to it. To avoid this, garbage collection is used to reclaim free space. After garbage collection, it is sufficient for the cache data log area 10332 to contain enough logs to construct a dirty image of the cache data area 10321. In other words, a log becomes unnecessary when the update range in the cache data area 10321 by that log is completely overwritten, or when it is made nonvolatile by asynchronous destaging. For this reason, when the cache data area 10321 is divided into several areas, for each area, logs with an older update order than the write of the entire area or the asynchronous destaging of the entire area are unnecessary logs, and newer logs with an update order after that are necessary logs. Therefore, when the log header 103231 is stored in the cache data log header management list 10323, the update order information of the write of the entire area or the asynchronous destaging of the entire area is registered in the invalidation table 10324 for each divided area. During garbage collection, logs in the collection range of the cache data log header management list that are newer than the update order listed in the invalidation table 10324 are deemed necessary logs, and are re-created (re-logged) from the corresponding location in the cache data area 10321. This leaves necessary logs in the cache data log area, and only unnecessary logs can be collected as free space in the cache data log area 10332.

[0031] These processes are the operations of the storage controller 1052 that is set to active and accepts I / O requests. The storage controller 1052 that is set to active creates a log and transmits the created log to the storage controller 1052 that is set to standby. The storage controller 1052 that is set to standby updates the cache data in the cache data area 10321 of the memory 1032 based on the log received from the storage controller 1052 that is set to active. In addition, the log received from the storage controller 1052 that is set to active is stored in the cache data log buffer 10322, the log is stored in the cache data log area 10332 on the storage device 1033 to be made nonvolatile, and the log header 103231 is stored in the cache data log header management list 10323 on the memory 1032. As a result, the cache data update is made redundant in the storage node 103 in which the storage controller 1052 that is set to standby is located.

[0032] Furthermore, since not only the log of cache data updates but also the log resulting from asynchronous destaging are made redundant, garbage collection using the invalidation table 10324 is possible even after the standby storage controller 1052 takes over I / O processing. Furthermore, since a log is created by re-logging during garbage collection, this log is also made redundant. For this reason, garbage collection only needs to be performed by the active storage controller 1052.

[0033] A specific example of the process will be described with reference to FIG. <Example of update by writing> The storage controller 1052 writes the updated data to the cache segment 103211#1. The storage controller 1052 creates a log in the cache data log buffer 10322 in the memory 1032. This log includes cache data and a log header. The storage controller 1052 stores the log (cache data and log header) in the cache data log buffer 10322 in the cache data log area 10332 of the storage device 1033, making it nonvolatile. Following this non-volatilization, the storage controller 1052 registers the log header in the cache data log header management list 10323 . If the log is an update of the entire cache segment 103211#1, the storage controller 1052 updates the sequence number of the log for the cache segment 103211#1 in the invalidation table 10324. Any log updates made to the cache segment 103211#1 with a sequence number smaller than this sequence number are unnecessary logs. The storage controller 1052 also resets the total log size of the cache segment 103211#1. If the log is a log in which part of the cache segment 103211#1 has been updated, the storage controller 1052 adds the amount of log data to the total log size of the cache segment 103211#1 in the invalidation table 10324.

[0034] <Example of destaging> The storage controller 1052 stores the cache segment 103211#3 in the permanent area 10331 of the storage device 1033. The storage controller 1052 creates a destage log in the cache data log buffer 10322 in the memory 1032. The destage log does not contain any cache data, but only a log header. The storage controller 1052 stores the log (log header) of the cache data log buffer 10322 in the cache data log area 10332 of the storage device 1033, making it nonvolatile. When destaging is performed, the data becomes unnecessary in units of cache segments, so there is no need to register it in the cache data log header management list 10323 . The storage controller 1052 updates the sequence number of the log for the cache segment 103211#3 in the invalidation table 10324. Any logs written to the cache segment 103211#3 with sequence numbers earlier than this sequence number are unnecessary logs. The storage controller 1052 also resets the total log size for the cache segment 103211#2.

[0035] <Garbage Collection Example> The storage controller 1052 references the log headers registered in the cache data log header management list 10323 in order from oldest to newest, and determines whether reglogging is required. If the address of the log header indicates that it is an update to cache segment #2, the storage controller 1052 compares the log sequence number associated with cache segment #2 in the invalidation table 10324 with the log sequence number of the log header. If the log sequence number of the log header is older, reglogging is not required. If the log sequence number of the log header is newer, the storage controller 1052 performs reglogging. In re-logging, the storage controller 1052 reads the update data from cache segment #2 and creates a log in the cache data log buffer 10322 in the memory 1032. This log contains the cache data and a log header. In other words, a log is created again based on the log header read from the cache data log header management list 10323. The storage controller 1052 stores the log (cache data and log header) in the cache data log buffer 10322 in the cache data log area 10332 of the storage device 1033, making it nonvolatile. Following this non-volatilization, the storage controller 1052 registers the log header in the cache data log header management list 10323 . If the log is an update of the entire cache segment 103211#2, the storage controller 1052 updates the sequence number of the log for the cache segment 103211#2 in the invalidation table 10324. Any log updates made to the cache segment 103211#2 with a sequence number smaller than this sequence number are unnecessary logs. The storage controller 1052 also resets the total log size of the cache segment 103211#2. If the log is a log in which part of the cache segment 103211#2 has been updated, the storage controller 1052 adds the size of the log data to the total log size of the cache segment 103211#2 in the invalidation table 10324. In this way, by selectively re-logging necessary logs, old logs become unnecessary. The storage controller 1052 releases the area that is no longer needed in the cache data log area 10332 of the storage device 1033, and reclaims the free area.

[0036] 5 is a diagram illustrating an overview of the compression function. The compression function is one example of various functions supported by the storage controller 1052. The compression function is a function that reduces capacity consumption by compressing user data received from the host device 101 into the host volume space using a data compression algorithm and storing the data in the cache data area 10321 and the storage device 1033, thereby saving the capacity of the storage device 1033 and reducing the cost of the storage device 1033.

[0037] Data received from the host device 101 into the host volume space is stored in the cache data area 10321. The processing at this time is the same as the write processing 401 shown in Fig. 12, but differs in that the data to be written to the cache data area 10321 is compressed and metadata indicating the compressed data and its location is written.

[0038] At this time, even if user data is written randomly to the host volume space, the compressed data is written in an append format to the cache data area 10321. This is because, in the compression function, the size of the data received from the host device 101 after compression is indefinite, and the old data and compressed data may differ in size and therefore cannot be replaced.

[0039] Furthermore, metadata is written to the cache data area 10321 by the storage controller 1052. The metadata includes, for example, information indicating the correspondence between the location of user data in the host volume space, the location of compressed data in the cache data area 10321, and the location on the storage device 1033, as well as free space information for the area for compressed data in the cache data area 10321 when additionally writing compressed data. For this reason, this metadata is written to the cache data area 10321 for each I / O, and is characterized by its small size and frequent overwrites.

[0040] 6 is a diagram showing an example of the configuration of the memory 1032. The memory 1032 includes a cache data area 10321, a cache data log buffer 10322, a cache data log header management list 10323, and an invalidation table 10324. The cache data log buffer 10322 temporarily stores logs of cache data. The cache data log header management list 10323 stores log headers 103231 of all cache data logs on the disk.

[0041] 7 is a diagram showing an example of the configuration of the storage device 1033. The storage device 1033 includes a permanent area 10331 and a cache data log area 10332. The permanent area 10331 is an area for storing user data, which is managed by the data protection controller 1053. The cache data log area 10332 is an area to which logs are saved in the log save process described below.

[0042] 8 is a diagram showing an example of the software module structure of the storage controller 1052. The storage controller 1052 executes a read process 400, a write process 401, an asynchronous destage process 402, a cache data update process 403, a log creation process 404, a confirmation process 405, a log evacuation process 406, a valid / invalid management process 407, an invalidation table registration process 408, a cache data log garbage collection process 409, and a cache segment reglog process 410. Details of each process will be described later.

[0043] 9 is a diagram showing the structure of the log header 103231. The log header is a table included in each log stored in the cache data log buffer 10322 on the memory 1032, the cache data log header management list 10323, and the cache data log area 10332 on the storage device 1033. Each log header 103231 includes fields for the log sequence number, update address, update size, and log type.

[0044] The log sequence number field stores a log sequence number that is uniquely assigned to each log. The update address field stores the address of the cache data area that each log updates. The update size field stores the size of the cache data that each log updates. The log type field stores a value (log type) that identifies the type of log that was created in accordance with the trigger for creating the log. Log types include, for example, a cache data log associated with write processing 401, or a destage log associated with asynchronous destage processing 402. The log type field may store a character string such as "cache data log" or "destage log", or may store a number such as "1" or "2".

[0045] 10 is a diagram showing the structure of the invalidation table 10324. The invalidation table is a table that associates a cache segment number that identifies a cache segment 103211 with the log sequence number of a log created in association with the write process 401 for the entire cache segment 103211 or the asynchronous destage process 402 for the cache segment 103211, and the total update size of the cache data log for the cache segment 103211 after that log (total log size).

[0046] 11 is an example of a flowchart of the read process 400. The read process 400 is called when a read I / O request is received from the host device 101, and is executed by the storage controller 1052. First, the read I / O request sent by the host device 101 is received via the front-end driver, and the read I / O request is interpreted to obtain the logical volume number and logical volume address of the read target (step 4001). Next, it is determined whether cache data corresponding to the logical volume number and logical volume address is present in the cache data area 10321 (cache hit) (step 4002). If there is a cache hit (step 4002; Yes), the data is read from the cache data area 10321 (step 4005), and the data is returned to the host (step 4006).

[0047] In the case of a cache miss (step 4002; No), a staging process is called (step 4003). The staging process is a process executed by the data protection controller 1053, and reads data corresponding to the logical volume number and logical volume address from the permanent area 10331 on the storage device 1033. The read data is stored in the cache data area 10321 on the memory 1032 (step 4004). At this time, the cache data update process 403, which will be described later, is called with the non-volatilization necessity set to "not required." Then, as in the case of a cache hit, the data is read from the cache data area 10321 (step 4005), and the data is returned to the host device 101 (step 4006).

[0048] FIG. 12 is an example of a flowchart of the write process 401. The write process 401 is called when a write I / O request is received from the host device 101, and is executed by the storage controller 1052. First, the write I / O request sent by the host device 101 is received via the front-end driver, and the write I / O request is interpreted to obtain the logical volume number and logical volume address of the write target (step 4011). Next, it is determined whether cache data corresponding to the logical volume number and logical volume address is present in the cache data area 10321 (cache hit) (step 4012). If there is a cache hit (step 4012; Yes), the data is stored in the cache data area 10321 (step 4014). At this time, the cache data update process 403 (described later) is called with the non-volatilization requirement set to "required." Next, the confirmation process (described later) is called (step 4015). Then, a write success response is sent to the host device 101 (step 4016).

[0049] In the case of a cache miss (step 4012; No), the cache segment 103211 is reserved (4013). Then, the process proceeds to step 4014, and thereafter the same processing as in the case of a cache hit is carried out.

[0050] 13 is an example of a flowchart of the asynchronous destage process 402. First, a dirty cache segment 103211 is searched for (step 4021), and if there is no such cache segment 103211 (step 4022; No), the process ends. If there is a dirty cache segment (step 4022; Yes), destage processing is executed for that cache segment 103211 (step 4023). The destage processing is executed by the storage controller 1052 and data protection controller 1053, and writes data corresponding to the logical volume number and logical volume address to the persistent area 10331 on the storage device 1033. Then, the log creation process 404 is called (step 4024).

[0051] 14 is a flowchart of the cache data update process 403. The cache data update process 403 is called when updating cache data in the memory 1032. When called, the memory address for identifying the cache data to be updated, the size, the update value, and information indicating whether or not non-volatilization is required are passed.

[0052] First, the cache data in the memory 1032 is updated (step 4031). Next, the passed non-volatilization necessity is referenced to determine whether or not non-volatilization is necessary (step 4032). Only if necessary (step 4032; Yes), the log creation process 404 is called (step 4033).

[0053] 15 is a flowchart of the log creation process 404. First, a log sequence number is determined (step 4041). Log sequence numbers are assigned in the order in which logs are created, and one log always corresponds to one log sequence number. Next, an area for writing the log is reserved in the cache data log buffer 10322 (step 4042). Next, a log header 103231 is created (step 4043). The above-mentioned log sequence number is stored in the sequence number field of the log header, a memory address for identifying the cache data to be updated is stored in the update address field, and the size of the cache data to be updated is stored in the update size field. In the log type field, "cache data log" is stored if called from the cache data update process 403, and "destaging log" is stored if called from the asynchronous destaging process 402.

[0054] Then, the log is stored in the cache data log buffer 10322 (step 4044). Specifically, the log header is stored at the beginning of the area secured in step 4042 in the cache data log buffer 10322, and the updated cache data is stored at a memory address obtained by adding the size of the log header 103231 to the secured area.

[0055] 16 is a flowchart of the confirmation process 405. The confirmation process 405 simply calls the log save process 406 (step 4051).

[0056] 17 is a flowchart of the log save process 406. First, the cache data log buffer 10322 is referenced and any unsaved logs are read (step 4061). Next, the unsaved logs are stored in the cache data log area 10332 on the storage device 1033 (step 4062). The storage location is immediately after the last log written. Next, the validity / invalidity management process 407, which will be described later, is called (step 4063). Then, the logs stored in the cache data log area 10332 are deleted from the cache data log buffer 10322 (step 4064).

[0057] 18 is a flowchart of the valid / invalid management process 407. First, the cache data log buffer 10322 is referenced, the log header 103231 of the log to be saved by the log saving process 406 is read, and the log type is confirmed (step 4071). If the log type is a cache data log (step 4072; Yes), the log header 103231 is stored in the cache data log header management list 10323 (step 4073). The storage location is immediately after the last stored log header 103231. Then, following step 4073, or if the log type is a destage log (step 4072; No), the invalidation table registration process 408 is called (step 4074). The log header 103231 is passed to the invalidation table registration process 408.

[0058] 19 is a flowchart of the invalidation table registration process 408. First, the log header 103231 passed from the valid / invalid management process 407 is referenced to confirm the log type (step 4081). If the log type is a cache data log (step 4082; Yes), the log header 103231 passed from the valid / invalid management process 407 is referenced to confirm the log size (step 4083). If the log size is smaller than the size of the cache segment 103211 (step 4084; Yes), the total log size of the entry in the invalidation table 10324 corresponding to the cache segment number calculated from the memory address is updated by adding the log size (step 4087). If the total log size of the entry exceeds a preset threshold (step 4088; Yes), it is registered in the threshold excess notification table (step 4089). The threshold excess notification table is a list of cache segments 103211 that require per-cache-segment reglogging, which creates a log of the cache segment size, in the per-cache-segment reglogging process 410, which will be described later. For example, the cache segment number of the cache segment 103211 in question is registered in the threshold excess notification table.

[0059] If the log type is not a cache data log (step 4082; No), it is checked whether the log type is a destaging log (step 4085). If it is a destaging log (step 4085; Yes), the log sequence number of the log is registered in the log sequence number field of the entry in the invalidation table 10324 that corresponds to the cache segment number calculated from the memory address (step 4086). Next, the total log size of the entry in the invalidation table 10324 is updated (step 4087). In this case, since it is a destaging log, the total log size is set to "0". Then, similar processing is performed from step 4088 onwards.

[0060] If the log size is equal to or larger than the size of the cache segment 103211 (step 4084; No), the process proceeds to step 4086. In this case, since the log type is a cache data log, the log size is added to the total log size (step 4087).

[0061] 20 is a flowchart of the cache data log garbage collection process 409. First, it is determined whether the free space in the cache data log area 10332 is equal to or less than a threshold (step 4091). If it is not equal to or less than the threshold (step 4091; No), the process ends without doing anything. If it is equal to or less than the threshold (step 4091; Yes), the process refers to the cache data log header management list 10323 in the memory 1032 and searches for the log headers 103231 starting from the oldest (lowest log sequence number) among the log headers 103231 in the forward direction. The log sequence number of the searched log header 103231 is compared with the log sequence number of the entry in the invalidation table 10324 that corresponds to the cache segment number calculated from the memory address of the log header. If the log sequence number of the searched log header 103231 is newer, the log is determined to be the log to be reglogged (step 4092). Next, a new log is created (reglogged) for the data indicated by the log (step 4093). Re-logging is a process for creating a log using a specified range of data in memory as log data instead of the updated cache data. Next, the log save process is called to write this log to the cache data log area 10332 on the storage device 1033 (step 4094), and then the area in the cache data log area 10332 that contains the log to be re-logged and has an address lower than that of the log to be re-logged is reclaimed as free space (step 4095).

[0062] 21 is a flowchart of the cache segment reglog processing 410. First, the threshold excess notification table is checked (step 4101) to determine whether there is a notification in the threshold excess notification table (step 4102). If there is no notification in the threshold excess notification table (step 4102; No), the processing ends without doing anything. If there is a notification in the threshold excess notification table (step 4102; Yes), one is taken from the threshold excess notification table and the cache segment 103211 to be reglogged is determined (step 4103). Next, a new log is created using the entire cache segment as the cache data for the log (step 4104). Then, the log save processing is called and this log is written to the cache data log area 10332 on the storage device 1033 (step 4105).

[0063] In this way, the write process (FIG. 12) calls the invalidation table registration process (FIG. 19) via the log save process (FIG. 17) and the valid / invalid management process (FIG. 18), and updates the invalidation table 10324. Then, the cache data log garbage collection process (FIG. 20) refers to the invalidation table 10324 in the process of determining the object to be re-logged (step 4092). In addition, the re-log processing for each cache segment (Figure 21) prevents log data from becoming too large by creating a new log of cache data from the entire cache segment for which the total log size shown in the invalidation table 10324 exceeds the threshold.

[0064] In this embodiment, there is no need to perform operations such as searching for a cache data log at the same address for each write process, or searching for a cache data log in the same address range as the destaged data for each asynchronous destage process; instead, the only operation required is to register in the invalidation table, resulting in low overhead and improved performance.

[0065] Furthermore, in this embodiment, because the table is updated during asynchronous destaging or when cache data of the cache segment size is updated, in workloads with many random write I / O requests and many asynchronous destaging, or workloads with many sequential write I / O requests, many logs do not need to be reglogged during cache data log garbage collection, resulting in small WA (Write Amplification). WA here refers to the ratio of writes to the cache data log area, including reglogging, to writes to the cache data log area due to write I / O requests. On the other hand, in workloads with many cache hits and few asynchronous destaging, or workloads with relatively small log sizes, there is a possibility of an increase in unnecessary reglogging, such as reglogging even though the cache data area 10321 is no longer up-to-date. However, by performing reglogging per cache segment before reglogging by cache data log garbage collection, WA and overhead can be reduced compared to reglogging by cache data log garbage collection, improving performance. [Example]

[0066] Next, a second embodiment will be described. Unlike the first embodiment, this embodiment has an invalidation table with the granularity of the smallest update unit. Although this increases overhead compared to the first embodiment, it allows for reliable overwrite determination, resulting in three differences: (1) the log sequence number field of the invalidation table is always registered even when updating, (2) reglogging for each cache segment is no longer necessary, and (3) since reglogging for each cache segment is no longer necessary, recording the log size is no longer necessary.

[0067] FIG. 22 is a diagram showing the structure of the invalidation table 10324 of the second embodiment. The invalidation table is a table that associates cache block numbers with log sequence numbers of logs created in association with the write process 401 to the cache block or the asynchronous destage process 402. The cache data area 10321 is divided into cache blocks, which are smaller units than the cache segments 103211. A cache block is the smallest unit of size for a write I / O request and, therefore, the smallest unit of size for a log update. What differs from FIG. 10 is that there is no total log size. The reason there is no total log size is that, because the cache block is the smallest unit of size for a log update, the latest log can be identified for all blocks in the cache data area 10321, and therefore there is no need to perform the reglog per cache segment process 410 to avoid unnecessary reglogging.

[0068] 23 is a flowchart of the invalidation table registration process 411 of the second embodiment. First, the process references the log header 103231 passed from the validity / invalidation management process 407, and registers the log sequence number of the log in question in the log sequence number field of the entry in the invalidation table 10324 that corresponds to the first block number of the update data calculated from the memory address (step 4111). Then, when the registration of log sequence numbers in the invalidation table 10324 for all blocks updated by the update data has been completed (4112; Yes), the process ends. If the registration has not yet been completed (4112; No), the next block number is registered in the invalidation table 10324.

[0069] In this embodiment, an operation to register all updated blocks in the invalidation table is required, so the overhead is greater than in embodiment 1. However, as in embodiment 1, a search operation is not required for each write process or asynchronous destage process, and only the operation to register in the invalidation table is required, so the overhead is low and performance is improved.

[0070] Furthermore, in the first embodiment, for workloads with many cache hits and few asynchronous destages, or workloads with relatively small log sizes, reglogging was performed for each cache segment to avoid unnecessary reglogging, thereby reducing WA. However, in this embodiment, the invalidation table entries are for each block, which is the smallest unit, so unnecessary reglogging due to the workload does not occur, and forced reglogging is not necessary. As a result, the overhead due to WA and reglogging can be further reduced, improving performance. [Example]

[0071] Next, a third embodiment will be described. In this embodiment, unlike the first and second embodiments, the invalidation table is switched between two types of granularity: cache segment unit granularity and minimum update unit granularity. This reduces overhead compared to the second embodiment, reduces memory usage, and enables overwrite determination when using an invalidation table with minimum update unit granularity. This results in two differences: (1) a pointer to an invalidation table with minimum update unit granularity is added to the invalidation table for each cache segment, and (2) the invalidation table is switched during the invalidation table registration process and the re-logging process for each cache segment.

[0072] 24 is a diagram showing an example of a configuration diagram of the memory 1032 of the embodiment 3. The difference from FIG. 6 is that the memory 1032 includes a coarse-grained revocation table 103241 and a fine-grained revocation table 103242 instead of the revocation table 10324.

[0073] Fig. 25 is a diagram showing the structure of the coarse-grained invalidation table 103241. What differs from the invalidation table 10324 of the first embodiment in Fig. 10 is that it has a field for a pointer to the fine-grained invalidation table 103242. The field for the pointer to the fine-grained invalidation table 103242 stores an address on the memory 1032 or an invalid value.

[0074] Fig. 26 is a diagram showing the structure of the fine-grained invalidation table 103242. What differs from the invalidation table 10324 of the second embodiment in Fig. 22 is that the field for the cache block number has been changed to a field for the block number within the cache segment. A fine-grained invalidation table 103242 exists for each cache segment.

[0075] Fig. 27 is a flowchart of the invalidation table registration process 412 of the third embodiment. There are two differences from Fig. 19. The first is that step 41207 is newly added after step 41206. After the log sequence number of the log in question is registered in the coarse-grained invalidation table 103241 (step 41206), if the value of the field of the pointer to the fine-grained invalidation table 103242 points to the fine-grained invalidation table 103242, the fine-grained invalidation table 103242 is deleted, and the value of the field of the pointer to the fine-grained invalidation table 103242 is changed to an invalid value (step 41207). The second is that if step 41204 is Yes, steps 41208 and 41209 are newly added. If the log size is smaller than the size of the cache segment 103211 (step 41204; Yes), it is determined whether the value of the field of the pointer to the fine-grained invalidation table 103242 of the entry for that cache segment 103211 in the coarse-grained invalidation table 103241 points to an address on the memory 1032 (step 41208). If it points to an address on the memory 1032 (step 41208; Yes), the log sequence number is registered in the entry for that block number in the fine-grained invalidation table 103242 that it points to (step 41209), and then the process ends. If it does not point to an address on the memory 1032 and is an invalid value (step 41208; No), the process proceeds to the process of updating the total log size in the coarse-grained invalidation table 103241 (step 41210).

[0076] Fig. 28 is a flowchart of the cache segment re-logging process 413 of the third embodiment. What differs from Fig. 21 is that steps 4136 and 4137 are newly added after step 4135. After the log saving process is performed (step 4135), it is determined whether the value of the pointer field to the fine-grained invalidation table 103242 of the entry for the cache segment 103211 in the coarse-grained invalidation table 103241 points to an address in the memory 1032 (step 4136; Yes). If it points to an address in the memory 1032 (step 4136; Yes), the process returns to the process of checking the threshold excess notification table (step 4131). If the value does not point to an address in memory 1032 and is an invalid value, a new fine-grained invalidation table 103242 is created, and the address in memory 1032 is registered in the pointer field to the fine-grained invalidation table 103242 of the entry for the cache segment 103211 in the coarse-grained invalidation table 103241 (step 4137).

[0077] This embodiment combines the advantages of embodiment 1 and embodiment 2. Embodiment 1 is suitable for workloads with many random write I / O and sequential write I / O requests and many asynchronous destages, while embodiment 2 is suitable for workloads with many cache hits and few asynchronous destages, or workloads with relatively small log sizes. Therefore, this embodiment improves performance for workloads such as compression functions that mix writing of compressed data written in an append format with writing of metadata with a small log size and many overwrites. [Example]

[0078] Next, a fourth embodiment will be described. Unlike the third embodiment, this embodiment has invalidation tables with both a cache segment unit granularity and a minimum update unit granularity. As a result, although the memory usage increases compared to the third embodiment, the overhead due to the invalidation table switching process is reduced compared to the third embodiment. This results in two differences: (1) the process of switching the invalidation table in the invalidation table registration process and the re-logging process for each cache segment is not necessary, (2) since re-logging for each cache segment is not necessary, there is no need to record the log size, and (3) two tables are referenced in the cache data garbage log collection process.

[0079] FIG. 29 is a diagram showing the structure of the coarse-grained invalidation table 103241 of the fourth embodiment. It differs from the invalidation table 10324 of the first embodiment in FIG. 10 in that it does not have a field for total log size. In addition to the coarse-grained invalidation table 103241, it also has a fine-grained invalidation table 103242. The fine-grained invalidation table 103242 here is assumed to be equivalent to the invalidation table 10324 of FIG. 22. As in the second embodiment, the cache block is the smallest unit of log update size, so the latest log can be identified for all blocks in the cache data area 10321, and there is no need to perform the reglog per cache segment process 410 to avoid unnecessary reglogging, so the coarse-grained invalidation table 103241 does not need a field for total log size.

[0080] Also, the cache data log garbage collection process differs from the cache data log garbage collection process 409 of the first embodiment in Fig. 20. The difference from the first embodiment is the process of determining the log to be re-logged (step 4092). In the first embodiment, the log sequence number in the invalidation table 10324 was compared with the log sequence number in the log header 103231, and if the log sequence number in the log header 103231 was newer, the log was determined to be the log to be re-logged. In this embodiment, the log sequence numbers in the coarse-grained invalidation table 103241, the fine-grained invalidation table 103242, and the log header 103231 are compared, and if the log sequence number in the log header 103231 is newer, the log is determined to be the log to be re-logged.

[0081] In all of the embodiments of the present invention, the granularity of the size of the invalidation table entries is set to be per cache segment size or per block size, but the size of the invalidation table entries may be set to any size. In this case, if the log is a cache data log or destaging log that is equal to or larger than the size of the invalidation table entry, the log sequence number field of the invalidation table is updated. In other words, if the log rewrites the entire range of the cache data area corresponding to the invalidation table entry, the log sequence number field of the invalidation table is updated.

[0082] Furthermore, in the first and third embodiments, the size of the re-logging performed by the re-logging process for each cache segment was the size of the cache segment, but it may be set to any size. For example, the invalidation table entry size and the size of the re-logging performed by the re-logging process for each cache segment may be set to half the cache segment size. In this case, in the invalidation table registration process 408 in FIG. 19 and the invalidation table registration process 412 in FIG. 26, the process of determining whether the size is smaller than the cache segment size (step 4084 or step 41204) is changed to a process of determining whether the size is smaller than half the cache segment size. Furthermore, in the re-logging process for each cache segment 410 in FIG. 21, the re-logging target was determined in units of the size of the cache segment (step 4103) and re-logging was performed in units of the size of the cache segment (step 4104), but each process is now performed in units of half the size of the cache segment.

[0083] Furthermore, in the third and fourth embodiments, two types of invalidation tables, a coarse-grained invalidation table and a fine-grained invalidation table, are used, but three or more types of invalidation tables may be used. For example, consider a case where three types of invalidation tables, a first-stage, second-stage, and third-stage invalidation table, are switched in order of coarseness. In this case, the processing flow differs in the invalidation table registration process 412 of FIG. 27. If the log type is a cache data log (step 41202; Yes) and the log size is confirmed (step 41203) to be equal to or greater than the entry size of the first-stage invalidation table (step 41204; No), the process proceeds to step 41206 as in FIG. 27. If the log size is smaller than the entry size of the first-stage invalidation table (step 41204; Yes), it is confirmed whether a pointer to the second-stage invalidation table exists in the first-stage invalidation table (step 41208). If a pointer to the second-stage invalidation table exists (step 41208; Yes), it is subsequently confirmed whether the log size is smaller than the entry size of the second-stage invalidation table. If it is smaller, it is confirmed whether a pointer to the third-stage invalidation table exists in the second-stage invalidation table, as in the first stage case. If the log size is equal to or larger than the entry size of the second-stage revocation table, the log sequence number is registered in the entry in the second-stage revocation table.

[0084] As described above, the disclosed system is a storage system 100 including a non-volatile storage device 1033, a processor that operates as a storage controller 1052 that processes reads and writes to the storage device 1033, and a memory 1032, wherein the storage device 1033 has a persistent area that destages data and stores it persistently, and a cache data log area 10332 that stores a cache data log to make it non-volatile, and the memory 1032 has a cache data area, and when the processor receives a write request, it stores data related to the write request in the cache data area provided in the memory 1032, creates a log header having a sequence number related to the memory storage of the data, and reads and writes the data stored in the memory from the log header. the data stored in the memory 1032 to a permanent area of ​​the storage device 1033, and a log header having the sequence number of the destage is created and registered in the invalidation table 10324; when the cache data log area of ​​the storage device 1033 is collected using a garbage collection method, a log header having a sequence number older than the sequence number registered in the invalidation table 10324 and data related to the log header are deleted from the cache data log area 10332 to free up storage space. Such a configuration and operation can improve the performance of the storage system. The cache data area has a plurality of partial areas, and the destaging is performed for each partial area, and the comparison of the sequence numbers and the release of storage areas are performed for each partial area. Furthermore, when all the data in the partial area of ​​1 is overwritten, a log header relating to the overwriting is created, and the sequence number of the log header is registered in the invalidation table. These operations enable efficient management of the area subject to garbage collection, contributing to improved performance.

[0085] Furthermore, according to the disclosed system, the log header includes address information indicating the range of the write or destage and a sequence number indicating the order of the logs, and when the processor collects the cache data log area of ​​the storage device using a garbage collection method, it identifies the corresponding partial area from the address information of the log header that is the subject of judgment as to whether or not collection is necessary, and compares the sequence number associated with the identified partial area in the invalidation table with the sequence number of the log header to judge whether or not collection is necessary. Therefore, logs before the asynchronous destage can be identified as unnecessary by garbage collection, ensuring consistency.

[0086] Furthermore, when the processor collects the cache data log area of ​​the storage device using a garbage collection method, it identifies the corresponding partial area from the address information of the log header that is the subject of the judgment on whether collection is necessary, compares the sequence number associated with the identified partial area in the invalidation table with the sequence number of the log header, and if the sequence number of the log header is a number earlier than the sequence number stored in the table, determines that the log indicated by the log header is unnecessary and collects it, and if the sequence number of the log header is not a number earlier than the sequence number stored in the table, determines that the log indicated by the log header is necessary, creates a new area in the cache data log area, and collects it. Therefore, logs before the log managed by the table are deemed unnecessary, and subsequent logs are retained for garbage collection, thereby ensuring consistency.

[0087] Furthermore, according to the disclosed system, the invalidation table holds the total size of the log header and data of the cache data log area for each partial area, and the processor selects the log header and data to be collected based on the total size. This avoids unnecessary re-logging, reduces WA, and improves performance.

[0088] The present invention is not limited to the above-described embodiment, but includes various modifications. For example, in the above embodiment, the memory 1032 is divided into cache segments, and the sequence numbers of the logs are registered, the total size of the logs is recorded, and re-logging is performed for each range, but the memory 1032 may be the smallest unit of data or metadata. Also, multiple invalidation tables may be used, and for example, an invalidation table divided into cache segments and an invalidation table divided into the smallest units of data or metadata may be used by switching between them, or both an invalidation table divided into cache segments and an invalidation table divided into the smallest units of data or metadata may be used. The above-described embodiment has been described in detail to clearly explain the present invention, and is not necessarily limited to those including all of the components described. Furthermore, not only can the components be deleted, but also replacement or addition of components is possible. [Explanation of symbols]

[0089] 100: Storage system, 101: Host device, 102: Network, 103: Storage node, 104: Management node, 1031: CPU, 1032: Memory, 1033: Storage device, 1053: Storage controller

Claims

1. a non-volatile storage device; a processor that operates as a storage controller for processing reads and writes to the storage device; Memory and A storage system comprising: the storage device has a permanent area for destaging data and permanently storing the data, and a cache data log area for storing a cache data log to make it nonvolatile; the memory has a cache data area; The processor: When a write request is received, data related to the write request is stored in a cache data area provided in the memory; creating a log header having a sequence number for storing the data in memory, storing the log header and the data stored in the memory in a cache data log area of ​​the storage device in response to the requester of the write request, and registering the sequence number of the created log header in an invalidation table; destaging the data stored in the memory to a permanent area of ​​the storage device, creating a log header having a sequence number of the destaging, and registering the sequence number in the invalidation table; When the cache data log area of ​​the storage device is collected by a garbage collection method, a log header having an older sequence number than the sequence number registered in the invalidation table and data related to the log header are deleted from the cache data log area to free up the storage area. A storage system comprising:

2. 2. The storage system according to claim 1, the cache data area has a plurality of partial areas, For each partial area, the destaging is performed, the sequence numbers are compared, and the storage area is released. A storage system comprising:

3. 2. The storage system according to claim 1, When all the data in the partial area of ​​one is overwritten, a log header relating to the overwriting is created, and the sequence number of the log header is registered in the invalidation table. A storage system comprising:

4. 2. The storage system according to claim 1, the log header includes address information indicating the range of the write or destage and a sequence number indicating the order of the logs; When collecting the cache data log area of ​​the storage device by a garbage collection method, the processor identifies a corresponding partial area from address information of the log header that is to be subjected to a judgment as to whether collection is necessary, and compares a sequence number associated with the identified partial area in the invalidation table with the sequence number of the log header to judge whether collection is necessary. A storage system comprising:

5. 5. The storage system according to claim 4, The processor: When collecting the cache data log area of ​​the storage device by a garbage collection method, a corresponding partial area is identified from address information of the log header that is to be used to determine whether collection is necessary; comparing the sequence number associated with the specified partial area in the invalidation table with the sequence number of the log header, and determining that the log indicated by the log header is unnecessary and collecting it if the sequence number of the log header is an earlier number than the sequence number stored in the invalidation table; If the sequence number of the log header is not an earlier number than the sequence number stored in the invalidation table, the log indicated by the log header is determined to be necessary, and the log is created in a new area of ​​the cache data log area and then collected. A storage system comprising:

6. 6. The storage system according to claim 5, the invalidation table holds a total size of a log header and data of the cache data log area for each of the partial areas; The processor selects the log header and data to be collected based on the total size. A storage system comprising:

7. 3. The storage system according to claim 2, A storage system characterized in that the size of the partial area matches the minimum unit of data to be stored in the memory.

8. 2. The storage system according to claim 1, the partial areas of the cache data area of ​​the memory include a first partial area that is large in size and stores data, and a second partial area that is small in size and stores metadata; For each partial area, the corresponding cache data log area is collected. A storage system comprising:

9. 1. A storage control method for controlling a storage system including a nonvolatile storage device, a processor that operates as a storage controller that processes reads and writes to the storage device, and a memory, the method comprising: the storage device has a permanent area for destaging data and permanently storing the data, and a cache data log area for storing a cache data log to make it nonvolatile; the memory has a cache data area; the processor: When a write request is received, data related to the write request is stored in a cache data area provided in the memory; creating a log header having a sequence number for storing the data in memory, storing the log header and the data stored in the memory in a cache data log area of ​​the storage device in response to the requester of the write request, and registering the sequence number of the created log header in an invalidation table; destaging the data stored in the memory to a permanent area of ​​the storage device, creating a log header having a sequence number of the destaging, and registering the sequence number in the invalidation table; When the cache data log area of ​​the storage device is collected by a garbage collection method, a log header having an older sequence number than the sequence number registered in the invalidation table and data related to the log header are deleted from the cache data log area to free up the storage area. A storage control method comprising:

Images