JP2008191797A - File system - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To improve operation speed, and to extend a service life of a flash memory, by reducing unnecessary data rewrite of a file system for the flash memory. <P>SOLUTION: When an address indicated by a head pointer and a tail pointer reaches the end of the flash memory, an address of a node to be modified closest to the head address of the flash memory is pointed so as to exclude a portion not to be garbage collected at the head of the flash memory among nodes not to be modified in garbage collection. <P>COPYRIGHT: (C)2008,JPO&INPIT

Description

  The present invention relates to a file system used by a computer or a microprocessor.

  In recent years, even in an OS for an embedded device such as a digital home appliance, an example in which a file system is provided in order to efficiently use a storage device is increasing. In embedded devices, a storage device using flash memory is often used. However, since flash memory has a characteristic that the number of times it can be erased and rewritten is finite, the characteristics of the file system may also be considered. Desired.

  In addition, since the power source of the portable device is unstable and there is a possibility that a sudden power interruption may occur during the writing of the file, the file system is required to have the ability to restore the consistency of contents even in such a case.

  An example of a file system that meets these requirements is jffs2 found in Non-Patent Document 1. jffs2 has two functions, journaling and wear leveling, to meet these requirements.

  The operation of these two functions will be described below.

  Journaling is a function in which the file system records a history of file changes, and this history is used to restore the integrity of the file system after a sudden power failure.

  Journaling in jffs2 does not record the file itself but records only the change history. The change part of the file is included as a difference in the history, and when reading the file, the oldest history related to the file is overwritten with the differences in all subsequent history, and the final Reproduce the contents of the latest file.

  In jffs2, the history is recorded in a node having a size of about several kilobytes for easy management. Therefore, a large file is expressed as a result of dividing its contents into sizes that can be recorded in the nodes and adding the contents of those nodes for convenience. Further, management information is added to each node, and the management information includes information regarding the version number of the node, the file to which the node belongs, and the occupation range occupied by the content held by the node in the file.

  The version number is a serial number assigned to all nodes, and is used to determine the new and old order of each node. In addition, since there is information on the occupied range, the contents of the file can be correctly reproduced even when the nodes are read in an irregular order or when only the middle of the file is changed.

  Also, a node whose occupation range overlaps among a plurality of nodes and is overwritten by a newer node and the content is not reflected in the final file is called an invalid node. Conversely, a node whose contents are reflected in the final file even if only a part is called an effective node. Even if it is a valid node, all of the occupied range is reflected in the final file contents, and only a part of the occupied range is reflected in the final file contents, and other parts are invalid It may be.

  jffs2 uses the node database instead of accessing the flash memory every time to read node management information. When jffs2 mounts the file system, it scans the flash memory, and stores management information of all nodes and addresses of the nodes in the flash memory in the node database. Also, the contents of the node database are updated when a new node is written or when an existing node is discarded.

  Next, the wear leveling function required for the flash memory file system will be described.

  Wear leveling is a function for making the number of rewrites of blocks in the flash memory uniform. Next, in order to explain why this function is necessary, the characteristics of rewrite of the flash memory will be described.

  The flash memory needs to have its contents erased before writing, and the number of erasable times that can be erased is a finite value of about 10,000 to 1,000,000 times. For convenience of use, flash memory is divided into blocks of several k to several tens of kbytes, and erasing is performed in units of blocks, so that the number of erasures of a specific block is limited to the upper limit. Even if it reaches the point where it cannot be used, other blocks with a smaller number of erasures can still be used. Note that the upper limit of the number of block erasures is known only statistically, and the remaining number of rewritable times for a specific block cannot be known until it is actually disabled.

  Since the flash memory has the characteristics as described above, if rewriting concentrates on a specific block, that block becomes unusable before other blocks, and the usable capacity of the entire flash memory is reduced. Therefore, in order to keep the capacity of the flash memory at a certain level or more until the product equipped with the flash memory reaches the end of its life, it is important to make the number of rewrites of each block as uniform as possible by wear leveling.

  Wear leveling in jffs2 is performed by managing writing and valid node addresses using the tail pointer and head pointer. In jffs2, the tail pointer holds the address on the flash memory where the node is to be written next, and the head pointer holds the address of the oldest valid node. Next, using FIG. 2 and FIG. 3, the operation of node writing and garbage collection processing using the tail pointer and the head pointer will be described.

  FIG. 2 is a schematic diagram showing an example of node arrangement in the flash memory being used by jffs2, (a) is an example of node arrangement, and (b) is the node immediately after writing a new node. (C) is an example of an arrangement of nodes after updating the tail pointer, (d) is an example of an arrangement of nodes, 1 is a flash memory, and 11 is the head of the flash memory. 12 is the end of the flash memory, 13 is the address pointed to by the head pointer, 14 is the address pointed to by the tail pointer, 101 is a range where there is no valid node, and 102 is the valid node An existing range 51 is a newly written node.

  FIG. 3 is a schematic diagram showing changes in the arrangement of nodes at the time of garbage collection. (A) is an example of arrangement before the garbage collection process, and (b) is after the node is discarded by the garbage collection process. (C) is an example of the arrangement after changing the node by garbage collection and copied, (d) is the arrangement after copying without changing the node by the garbage collection process. For example, 1 is the flash memory, 11 is the head of the flash memory, 12 is the end of the flash memory, 13 is the address pointed to by the head pointer, 14 is the address pointed to by the tail pointer, 101 Is a range where there is no valid node, 102 is a range where there is a valid node, 52a is a node, and 52b is no In it, 52c is a node.

  First, using the tail pointer will be described with reference to FIG. As an example, the arrangement of nodes in the flash memory 1 is as shown in FIG. When writing a node to the flash memory 1, the node 51 is written to the address 14 pointed to by the tail pointer as shown in FIG. After the writing, as shown in FIG. 2C, the contents of the tail pointer are updated to the next address of the node 51, so that the node 51 becomes a valid node.

  When node writing is repeated, the address 14 pointed to by the tail pointer approaches the end 12 of the flash memory 1, but after reaching the end 12, the address 14 pointed to by the tail pointer is restored to the beginning 11 of the flash memory 1 Continue to operate. In the example shown in FIG. 2D, the node writing continues even after the tail pointer returns to the head 11 of the flash memory 1, so that the range 102 in which a valid node exists is the side closer to the head 11 and the tail 12 It is divided on the side close to.

  Next, the usage of the head pointer at the time of garbage collection will be described with reference to FIG.

  FIG. 3A shows an example of the arrangement of nodes before the garbage collection process. The range 101 in which no valid node exists is an area that can be erased and reused for writing. However, if the writing to the flash memory 1 is continued, this range gradually narrows, and writing to a new node becomes impossible.

  The range 102 in which valid nodes exist includes invalid nodes and partially invalid nodes, and the garbage collection processing is performed by the following procedure. Collect and increase the area for writing. The garbage collection process starts when the difference between the address 14 pointed to by the tail pointer and the address 13 pointed to by the head pointer becomes below a certain level.

  In the garbage collection process, jffs2 examines the node 52a at the address 13 pointed to by the head pointer, and performs the following process depending on whether the node 52a is invalid or has an invalid part.

  If the node 52a is an invalid node, the node 52a is discarded and the address 13 pointed to by the head pointer is simply updated to the next address of the node 52a. The arrangement of the nodes after this processing is as shown in FIG. 3B, and the range 101 where no valid nodes exist is expanded by the size of the node 52a.

  If the node 52a is a node having an invalid part, the contents of the node 52a are overwritten and updated with the contents of the final file, and are written as the new node 52b at the address 14 pointed to by the tail pointer. Thereafter, the address 13 pointed to by the head pointer is updated to the next address of the node 52a. The arrangement of the nodes after this processing is as shown in FIG. 3 (c), and the size of the range 101 where no valid node exists does not change, but all the contents of the node 52b are reflected in the contents of the final file. On the other hand, a node whose occupation range overlaps with the node 52b becomes an invalid node or a node having an invalid part, and if it becomes an invalid node, the subsequent garbage collection Discarded.

  If the node 52b is within the upper limit of the node size, the occupied range of the node 52b can be expanded and overwritten. In this case, the chance that the node whose occupation range overlaps with the node 52b becomes invalid increases.

  When the node 52a is a valid node having no invalid part, the node 52a is simply copied as the new node 52c at the address 14 indicated by the tail pointer, and the address 13 indicated by the head pointer is updated to the next address of the node 52a. To do. The arrangement of the nodes after this processing is as shown in FIG.

  The above garbage collection process is continued until a desired free space is obtained.

  In the above, a node having no invalid part is a node that is simply copied without changing the contents at the time of garbage collection, and is hereinafter referred to as a node that does not need to be changed. Further, a node having an invalid part needs to be changed in garbage collection, and together with an invalid node to be discarded, it is hereinafter referred to as a node that needs to be changed.

  If the address 13 pointed to by the head pointer reaches the end 12 of the flash memory 1 during the above garbage collection process, the address 13 pointed to by the head pointer is returned to the head 11 of the flash memory 1 to operate the file system. to continue.

  As described above, the arrangement of valid nodes is managed by the head pointer, writing to the flash memory is managed by the tail pointer, and this tail pointer scans the entire range of addresses in the flash memory. The number of writes to all addresses is uniform, and wear leveling can be realized.

  In addition, as a method of realizing wear leveling, not only a method of giving a file system its function as in jffs2, but also a method of giving a memory chip a hardware leveling function as seen in Patent Document 1. Also, as can be seen in Non-Patent Document 2, there is also a method that is realized by a device driver lower than the file system.

JFFS: The Journalling Flash File System David Woodhouse Red Hat, Inc. UBI-Unsorted Block Images Thomas Gleixner, Frank Haverkamp, Artem Bityutskiy IBM corp. JP 2001-67258 A

  In jffs2, which is a conventional example, at the time of garbage collection, nodes that do not need to be changed only move in the flash memory, and do not contribute to securing the capacity that is the purpose of garbage collection. In particular, if there are many files with low frequency in the file system, there are many nodes that do not need to be changed during garbage collection, and the garbage collection process is repeated to secure the desired free space, and the processing time Increases and the number of rewrites also increases. This shortens the lifetime of the flash memory.

  An object of the present invention is to obtain a file system capable of reducing unnecessary node movement that occurs during jff2 garbage collection processing, thereby speeding up the garbage collection processing operation and extending the life of the flash memory. There is.

  To solve the above problem, when the address pointed to by the head pointer and tail pointer reaches the end of the flash memory, the address of the node that needs to be changed closest to the head address of the flash memory is restored.

  According to the present invention, among the nodes that do not need to be changed at the time of garbage collection, those at the head of the flash memory are not subjected to garbage collection processing. Also, nodes in a continuous area in which nodes that do not need to be changed from the beginning of the flash memory are not subject to garbage collection processing. Therefore, since the number of garbage collection targets can be reduced, it is possible to speed up the processing operation and extend the life of the flash memory.

  Note that the position of the nodes in the continuous area does not change on the flash memory until the node needs to be changed. Further, nodes that do not need to be changed outside the continuous area are incorporated into the continuous area if they are copied at the position in contact with the continuous area at the time of garbage collection, and are excluded from the next garbage collection processing target. Therefore, nodes that do not need to be changed while garbage collection is repeated are collected in the above-described continuous area, and are collectively excluded from the object of garbage collection. Therefore, the effect of the present invention is further enhanced.

  Note that even if a node is once collected in a continuous area, if the file to which the node belongs is changed and the node needs to be changed, the next time the head pointer and tail pointer are restored, the address of that node is set. In order to return, it is again subject to garbage collection. At that time, since the continuous area temporarily decreases, the number of garbage collection targets increases and the effect of the present invention is reduced. As described above, nodes that do not need to be changed again gather in the continuous area while the garbage collection is repeated. .

  As the above is repeated, nodes belonging to files with a low change frequency are placed near the top of the flash memory, and nodes belonging to files with a high change frequency are placed near the end of the flash memory, and the change frequency is low Even if the file changes, it is naturally optimized to minimize the nodes that are affected during garbage collection.

  According to the present invention, the rewrite processing by garbage collection is concentrated at a position near the end of the flash memory, which is an operation contrary to the purpose of wear leveling, but the technique found in Patent Document 1 and Non-Patent Document 2 is used in combination. You can wear leveling.

  Hereinafter, the present embodiment will be described with reference to the drawings. The present invention is not limited to the illustrated example.

  First, the configuration of the file system according to the present embodiment will be described with reference to FIG.

  The flash memory 1 writes data to or reads data from the designated address by designating an address and data by a specific protocol from the device driver 2. The device driver 2 is a software component that directly reads / writes data from / to the flash memory 1 and absorbs the differences among the types of flash memory and provides a unified interface to the file system 3. The file system 3 uses the interface provided by the device driver 2 to read / write nodes from / to the flash memory 1. The application 4 requests the file system 3 to read / write a file.

  The file system 3 includes a file system control unit 31, a node database 32, a head pointer 33, a tail pointer 34, and a return processing pointer 35.

  The node database 32 holds the management information of all the nodes in the flash memory 1 and the addresses in the flash memory 1 of the node, and the initial value is the file system when the file system is mounted. It is obtained by the controller 31 scanning all the nodes in the flash memory 1.

  The node management information includes at least the version number of the node, the file name to which the node belongs, and information about the occupation range occupied by the content held by the node in the file. The file system control unit 31 stores the file By referring to the node database 32 at the time of reading, all nodes necessary for reproducing the file can be specified, and the stored address of the node can be obtained.

  Further, the file system control unit 31 can detect that the occupation ranges of a plurality of nodes are overlapped by referring to the node database 32, and determine which node content should be used as the contents of the overlap range. Can be determined from the version number.

  The head pointer 33 holds an address at which garbage collection is started in the flash memory 1, and the tail pointer 34 holds an address in the flash memory 1 where a node is to be written next. The initial value of the tail pointer 34 is set to the next address of the newest node in the node database 32 when the node database 32 obtains the initial value. The initial value of the head pointer 33 is determined by scanning the node from the address indicated by the tail pointer 34 toward the end in the flash memory when the initial value of the tail pointer 34 is determined. Set the address.

  The return processing pointer 35 is used for return processing for returning the contents of the head pointer 33 and the tail pointer 34 to appropriate addresses when the addresses pointed to by the head pointer 33 and the tail pointer 34 reach the end of the flash memory 1. Used for.

  Next, the write operation of the file system according to the present embodiment will be described with reference to FIG.

  4 in FIG. 4A is a file requested by the application 4 to write, and the application 4 sends the file 6 to the file system control unit 31 together with the write request. The file system control unit 31 divides the contents of the file 6 into sizes that can be stored in the nodes, and adds the management information 7 to generate the nodes 53a, 53b, and 53c shown in FIG. Next, the file system control unit 31 sends each node to the device driver 2 and requests writing. As a result of the writing process of the device driver 2, the node 53a, the node 53b, and the node 53c are arranged on the flash memory 1 as shown in FIG. 5C, for example.

  In addition, the file system control unit 31 registers the management information 7 of the generated node and the address at which the node is written in the node database 32, and sets the contents of the tail pointer 34 to the next address of the node at which it was last written. Update.

  With the above operation, the file system 3 according to the present embodiment writes the file.

  Next, the operation of rewriting an existing file by the file system according to the present embodiment will be described with reference to FIG.

  The application 4 requests the file system control unit 31 to rewrite a part of the file 6 and sends the changed part 61 to the file system control unit 31 together with the rewrite request. The file system control unit 31 divides the changed portion 61 into sizes that can be stored in the node, and adds the management information 7 to generate the node 53d shown in FIG. Next, the file system control unit 31 sends the node 53d to the device driver 2 and requests writing.

  As a result of the writing process of the device driver 2, the node 53d is arranged on the flash memory 1 as shown in FIG. 6C, for example.

  In addition, the file system control unit 31 registers the management information 7 of the generated node and the address at which the node is written in the node database 32, and sets the contents of the tail pointer 34 to the next address of the node at which it was last written. Update.

  With the above operation, the file system 3 according to the present embodiment rewrites the file.

  Next, an operation of reading a file by the file system according to the present embodiment will be described with reference to FIG.

  First, the application 4 sends a read request for the file 6 to the file system control unit 31. The file system control unit 31 refers to the node database 32, identifies the node 53a, the node 53b, the node 53c, and the node 53d that belong to the designated file 6, identifies the version number of these nodes, the occupancy range of the nodes, The address in the flash memory 1 is obtained.

  Next, using the device driver 2, the file system control unit 31 reads out the nodes 53a, 53b, 53c, and 53d arranged in the flash memory 1 as in the example of FIG. The contents held by each node are arranged in the occupation range in order of the older version number. In this process, if there is a node with an overlapping occupation range, the overlapping part of the node with the old version number is overwritten with the contents of the new node. In the example of FIG. 6B, a part of the content held by the node 53b and all of the content held by the node 53c are overwritten by the content held by the node 53d. As a result, the content of FIG. File 6 is obtained.

  Note that the operation of reading from the flash memory 1 may be omitted for nodes having only contents that are not reflected in the contents of the final file, as in the example of the node 53c described above.

  The file system control unit 31 passes the file 6 obtained as described above to the application 4, and the reading operation is completed.

  Next, the operation of the garbage collection process of the file system according to this embodiment will be described with reference to FIGS.

  FIG. 7A shows the arrangement of nodes in the flash memory 1 before the start of garbage collection. The range 101 in which there is no valid node between the address 14 indicated by the tail pointer and the address 13 indicated by the head pointer. Is less than a certain value, the file system control unit 31 starts the garbage collection process according to the procedure shown in the flowchart of FIG.

  First, in process S11 of FIG. 8, the file system control unit 31 refers to the node database 32, identifies the file to which the node 54a pointed to by the head pointer 33 belongs, and management information 7 of all the nodes belonging to the identified file. Then, the process proceeds to step S12.

  Next, in process S12, the contents of the node 54a are determined from the node management information 7 acquired in process S11. If the node 54a is invalid, the process branches to process S13, and there is an invalid part in the contents of the node 54a. If so, the process branches to process S14. If all the contents of the node 54a are valid, the process branches to process S16.

  In process S13, the process proceeds to process S17 without doing anything.

  In the process S14, the file reading process is performed for the range occupied by the node 54a in the file, the final content of the file is acquired for the occupied range, and the process proceeds to the process S15. The occupied range may be extended beyond the size of the node 54a to the maximum size that can be accommodated in the node to obtain the final contents of the file. This is because expanding the occupation range increases the chances of invalidating other nodes having overlapping occupation ranges.

  In the process S15, the node 54b is generated with the contents acquired in the process S14, written in the address 14 pointed to by the tail pointer, the node 54b is registered in the node database 32, the tail pointer 34 is updated, and the process proceeds to the process S17.

  In the process S16, a node 54c having the same contents as the node 54a is generated, written to the address 14 pointed to by the tail pointer, the node 54c is registered in the node database 32, the tail pointer 34 is updated, and then the process proceeds to a process S17.

  In the process S17, the head pointer 33 is updated to the next address of the node 54a, and the node 54a is deleted from the node database 32. Control goes to step S18. When the process S17 is completed, the arrangement of the nodes in the flash memory 1 is as shown in the example of FIG. 7B when the process S13 is performed, and when the process S14 is performed, the arrangement of the nodes shown in FIG. In the case of passing through the process S16, the example is as shown in FIG.

  In the process S18, the difference between the head pointer 33 and the tail pointer 34 is confirmed. If it does not reach the predetermined value, the process proceeds to step S11.

  In the present embodiment, the garbage collection process is performed according to the above procedure.

  Next, with reference to FIGS. 9 and 10, the operation of the return processing of the head pointer 33 and the tail pointer 34 in the file system according to this embodiment will be described.

  When the address 13 pointed to by the head pointer reaches the end 12 of the flash memory 1 during the garbage collection process, the file system control unit 31 performs the next garbage collection process according to the procedure shown in the flowchart of FIG. The head pointer 33 is restored to an appropriate address.

  First, in process S21 of FIG. 10, the content of the return process pointer 35 is set to the head 11 of the flash memory 1, and the process proceeds to process S22.

  In the process S22, the file to which the node pointed to by the return process pointer 35 belongs is specified with reference to the node database 32, and the management information 7 of all the nodes belonging to the specified file is acquired, and the process proceeds to the process S23.

  In the process S23, the contents of the node pointed to by the return process pointer 35 are determined from the management information acquired in the process S22. If all the contents of the node pointed to by the return process pointer 35 are valid and need not be changed, the process proceeds to the process S24. If the node branches and the node pointed to by the return processing pointer 35 is invalid, or if the node needs to be changed with an invalid part in the contents, the process branches to step S25.

  In process S24, the contents of the return process pointer 35 are updated to the next address of the node pointed to by the return process pointer 35, and the process proceeds to process S22.

  In step S25, the contents of the return processing pointer 35 are copied to the head pointer 33, and the process ends.

  In the example of FIG. 9, as a result of the above procedure, the contents of the return processing pointer 35 become the address 15 of the node 57 that needs to be changed, and the head pointer 33 also returns to the address 15.

  When the address 14 pointed to by the tail pointer reaches the end 12 of the flash memory 1, the tail pointer 34 is restored to the same address 15 as the head pointer 33. This can be realized by holding the contents of the return processing pointer 35 without discarding them and using the tail pointer 34 for returning.

  In FIG. 9, in jffs2, which is a conventional example, the addresses pointed to by the head pointer and tail pointer move in the entire range of the flash memory 1, and all the nodes in the flash memory 1 are subjected to garbage collection processing. In the embodiment, the addresses pointed to by the head pointer and the tail pointer move between the ranges 103, and nodes outside the range 103 are not subjected to garbage collection processing.

  In the present invention, processing time is shortened and wasteful by removing nodes that are out of the range 103 and are only moved unnecessarily without changing the contents at the time of garbage collection processing. Rewriting can prevent shortening the lifetime of the flash memory.

  The present invention is particularly effective in a file system using a flash memory as a medium, but can also be used in a medium other than the flash memory. For example, in optical disk media, it is preferable in terms of speed to write data by a write-once operation rather than a rewrite operation. However, if the present invention is applied to such a medium, the rewrite operation is reduced and high speed can be expected.

It is a block diagram which shows the software internal structure of the file system which concerns on this Embodiment, and a surrounding software structure. It is a schematic diagram which shows the example of arrangement | positioning of the node in the flash memory in use by jffs2 which is a prior art example. It is a schematic diagram which shows the change of arrangement | positioning of the node at the time of garbage collection in jffs2 which is a prior art example. (a) is a schematic diagram of a file requested to be written, (b) is a schematic diagram of a node created from the file, and (c) is a schematic diagram showing an example of arrangement of nodes on the flash memory. (a) is a schematic diagram of a file requested to be rewritten, (b) is a schematic diagram of a node created from the changed portion, and (c) is a schematic diagram showing an example of arrangement of nodes on the flash memory. . (a) is a schematic diagram of an example of arrangement of nodes on the flash memory, (b) is a schematic diagram of read nodes, and (c) is a file reconstructed from the nodes. (a) is a schematic diagram showing an example of arrangement of nodes before garbage collection processing, (b) is a schematic diagram showing an example of arrangement of nodes after discarding nodes by garbage collection processing, (c ) Is a schematic diagram showing an example of the arrangement of nodes after being copied by changing the node by the garbage collection process, and (d) is an example of the arrangement of nodes after being copied without changing the node by the garbage collection process. It is a schematic diagram which shows. It is a flowchart which shows the procedure of the garbage collection process of the file system which concerns on this Embodiment. It is a schematic diagram which shows arrangement | positioning of the node in flash memory when a head pointer returns from the tail of flash memory in the file system concerning this Embodiment. It is a flowchart which shows the procedure of the return process of the file system which concerns on this Embodiment.

Explanation of symbols

1 ... flash memory, 11 ... start, 12 ... end, 13 ... address pointed to by head pointer,
14 ... address pointed to by tail pointer, 15 ... address, 101 ... range without valid node 102 ... range with valid node, 103 ... range, 2 ... device driver, 3 ... file system, 31 ... file system control unit, 32 ... node database, 33 ... head pointer, 34 ... tail pointer, 35 ... return processing pointer, 4 ... application, 51 ... node, 52a ... node, 52b ... node, 52c ... node, 53a ... node, 53b ... node, 53c ... node, 53d ... node, 54a ... node, 54b ... node, 54c ... node, 55 ... node without change, 56 ... node without change, 57 ... node with change, 6 ... file, 61 ... change part, 7 ... Management information

Claims (5)

Temporary storage means;
Write position storage means for holding an address on the temporary storage means for writing a node;
A garbage collection start position storage means for holding a start address of garbage collection processing of the file system;
When a file change is requested, a node containing the changed difference of the file is generated, the generated node is written to the address stored in the write position storage means, and the write position storage means Perform file change processing to update the contents to the next address of the written node,
When reading of the file is requested, the node is read from the temporary storage means, the difference of the change that is the content of the read node is accumulated, and the result of accumulating the difference of the change is returned as the content of the file. Perform file read processing,
Control means for performing a garbage collection process when the difference between the writing position storage means and the garbage collection start position storage means is a predetermined value or less,
The control means, when performing garbage collection,
As a return process when the content of the garbage collection start position storage means reaches the end address of the temporary storage means, the head address of the temporary storage means is set in the temporary storage means, and the temporary storage means Check the node of the address that is the content,
If all the contents of the confirmed node are valid,
A file system for checking the node again after updating the contents of the temporary storage means to the next address of the node. Temporary storage means;
Write position storage means for holding an address on the temporary storage means for writing a node;
A garbage collection start position storage means for holding a start address of garbage collection processing of the file system;
When a file change is requested, a node having the changed difference of the file as a content is generated, the generated node is written at an address stored in the write position storage means, and the write position storage means Perform file change processing to update the contents to the next address of the written node,
When reading of the file is requested, the node is read from the temporary storage means, the difference of the change that is the content of the read node is accumulated, and the result of accumulating the difference of the change is returned as the content of the file. Perform file read processing,
Control means for performing a garbage collection process when the difference between the writing position storage means and the garbage collection start position storage means is a predetermined value or less,
The control means, when performing garbage collection,
As a return process when the content of the garbage collection start position storage means reaches the end address of the temporary storage means, the start address of the temporary storage means is set in the temporary storage means, and the temporary storage means Check the node of the address that is the content,
When the content of the confirmed node is invalid or partially invalid,
A file system for copying the contents of the temporary storage means to the garbage collection start position storage means.   3. The file system according to claim 1, wherein the temporary storage means is a flash memory.   The file system according to claim 3, wherein the flash memory has a wear leveling function.   5. The file system according to claim 4, wherein a device driver having a wear leveling function is used as a device driver for reading and writing the flash memory.

Images