JP2013196155A - Memory system - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a memory system in which exhaustion of a flash memory is mitigated by effectively using storage area storing a pointer.SOLUTION: When snap shot conditions are satisfied, a management table is stored from a first storage part to a first block of a second storage part as a snap shot, a pointer indicating the storage location of the management table is stored in a write-in unit in a second block of the second storage part, and a part of the management table is stored in an unwritten area in the write-in unit in the second block where the pointer is stored.

Description

  Embodiments described herein relate generally to a memory system including a nonvolatile semiconductor memory.

  In a solid state drive (SSD), a management table such as a logical-physical conversion table indicating a correspondence relationship between a logical address (LBA) supplied from the outside and a physical address indicating a position where data is stored on the flash memory. Data is often managed using These management tables are expanded from a nonvolatile flash memory to a volatile memory such as a DRAM at startup, and the management table expanded in the volatile memory is updated every time data is written on the flash memory. Since the management table is used across power interruptions, it is necessary to back up the volatile memory to the flash memory.

  There is also a method of storing a pointer indicating the storage position of management information on the flash memory on the flash memory. In this pointer method, management information is acquired by first reading a pointer from the flash memory and then reading data at a position on the flash memory indicated by the pointer.

JP 2009-2111188 A

  An object of one embodiment of the present invention is to provide a memory system that reduces fatigue of a flash memory by effectively using a storage area in which pointers are stored.

  According to one embodiment of the present invention, a memory system includes a volatile first storage unit and a nonvolatile memory in which writing is performed in a predetermined writing unit and erasing is performed in a block unit larger than the writing unit. Data is transferred between the host device and the second storage unit via the second storage unit and the first storage unit, and the logical address designated by the host device and the second storage unit A management table including logical-physical conversion information that correlates with a data storage position is transferred from the second storage unit to the first storage unit at the time of activation, and is updated based on the management table while updating the transferred management table. And a controller for managing data in the two storage units. When the first condition is satisfied, the controller stores the management table as a snapshot from the first storage unit to the first block of the second storage unit, and stores a pointer indicating the storage position of the management table. A table management unit for storing a part of the management table in an unwritten area in the writing unit of the second block in which the pointer is stored, and storing in a writing unit in the second block of the second storage unit Is provided.

FIG. 1 is a block diagram illustrating a configuration example of an SSD. FIG. 2 is a diagram conceptually showing how snapshots and logs are generated. FIG. 3 is a diagram showing a snapshot storage system according to a comparative example. FIG. 4 is a diagram illustrating a snapshot storage method according to the embodiment. FIG. 5 is a diagram illustrating an example in which the next snapshot is stored in an unwritten area of a block. FIG. 6 is a diagram illustrating an example of storing logs in an unwritten area of a block.

  Hereinafter, a memory system according to an embodiment will be described in detail with reference to the accompanying drawings. In addition, this invention is not limited by this embodiment.

(First embodiment)
FIG. 1 is a block diagram illustrating a configuration example of an SSD (Solid State Drive) 100. The SSD 100 is connected to a host device (hereinafter abbreviated as a host) 1 such as a personal computer or a CPU via a host interface 2 such as an ATA interface (ATA I / F), and functions as an external storage device of the host 1. The host 1 is a CPU of an imaging apparatus such as a CPU of a personal computer, a still camera, or a video camera. The SSD 100 includes a host interface 2, a NAND flash memory (hereinafter abbreviated as “NAND”) 10 as a nonvolatile semiconductor memory, a RAM 20 that is a volatile semiconductor memory that can be accessed at a higher speed than the NAND 10, and a controller 30. Prepare.

  The RAM 20 stores a storage area as a write buffer 21 for temporarily storing data when data from the host 1 is written to the NAND 10, and a storage area for storing and updating management information for managing the SSD 100. And a work area for temporarily storing data read from the NAND 10. The management information for managing the SSD 100 includes a master table 22 that is a management table for managing the SSD 100 and a master log 23 that includes difference information before and after the change related to the change to be applied to the master table 22. The master table 22 is obtained by expanding the backup management table 12 stored in the NAND 10 at the time of startup or the like. As the RAM 20, volatile DRAM, SRAM, or the like is employed.

  The NAND 10 has a memory cell array in which a plurality of memory cells are arranged in a matrix, and each memory cell can store multiple values using an upper page and a lower page. The NAND 10 is constituted by a plurality of memory chips, and each memory chip is constituted by arranging a plurality of blocks which are data erasing units. The NAND 10 performs data writing and data reading for each page. That is, the data write unit and read unit in the NAND 10 are pages. The block is composed of a plurality of pages.

  The NAND 10 stores a user data storage unit 11 that stores user data designated by the host 1 and various management information for managing the SSD 100. The management information includes a backup management table 12 as a backup of the master table 22, a backup log 13 as a backup of the master log 23, and the like.

  When writing data to the SSD 100, the host 1 inputs a write command and write data including an LBA (Logical Block Addressing) as a logical address and a data size via the host interface 2 to the SSD 100. LBA is a logical address in which a serial number from 0 is assigned to a sector (size: eg, 512 B).

  As management information managed by the master table 22 (backup management table 12), a logical-physical conversion table showing the relationship between the LBA as a logical address and the storage location (physical address) on the NAND 10 where the data is stored. Block management table for managing block usage / unused information indicating whether each block of the NAND 10 is in use or unused, bad block information for identifying bad blocks that cannot be used as a storage area due to many errors, etc. Etc.

  The relationship between the management information on the NAND 10 and the management information on the RAM 20 will be described. The management information managed by the master table 22 enables data exchange between the host 1 and the NAND 10. The backup management table 12 is stored in the nonvolatile NAND 10, and at the time of startup, the backup management table 12 stored in the NAND 10 is expanded as a master table 22 in the work area of the RAM 20, and the expanded master table 22 is expanded. The master table 22 is updated as the controller 30 uses it.

  Even if the power is turned off, the master table 22 needs to be restored to the state before the power is turned off. Therefore, the master table is stored in the nonvolatile NAND 10 as the backup management table 12. The snapshot refers to the entire backup management table 12 on the NAND 10, and storing the master table 22 expanded in the RAM 20 in the NAND 10 as it is is also expressed as taking a snapshot. As described above, the master log 23 includes the change difference information of the master table 22. Since the snapshot is taken every time the master table 22 is updated, the speed is slow and the number of writes to the NAND 10 increases. Therefore, usually only the log as the change difference is stored in the NAND 10 as the backup log 13. Go. Reflecting the master log 23 in the master table 22 and storing it in the NAND 10 is also expressed as committing.

  FIG. 2 shows how snapshots and logs are updated when data is updated. When the controller 30 updates the data, the change contents added to the master table 22 are accumulated in the master log 23 on the RAM 20. Depending on the type of the management table, the master table 22 is directly updated and the updated contents are accumulated in the master log 23, or the master table 22 is not directly changed, and a change area is secured on the master log 23. Update content is recorded in the area. In the data read / write process, the master log 23 stored in addition to the master table 22 is also referred to.

  When the data update is stable, commit the log. In the commit process, the contents of the master log 23 are reflected in the master table 22 as necessary, and the contents of the master log 23 are stored in the NAND 10 as the backup log 13 and made nonvolatile. The snapshot is stored in the NAND memory 10 when a snapshot condition is satisfied during a normal power-off sequence or when the storage area of the master log 23 is insufficient. When the log or snapshot has been written to the NAND 10, the management table is non-volatile.

  In FIG. 1, the controller 30 includes a read / write control unit 31, a table management unit 32, and a log management unit 33. When the read command and the LBA as the read address are input from the host 1, the read / write control unit 31 reads the data corresponding to the LBA from the write buffer 21 or the NAND 10 by referring to the master table 22 and the master log 23. Data is transmitted to the host 1. When a live command, an LBA as a write address, and write data are input, the read / write control unit 31 writes the data specified by the LBA into the write buffer 21. If there is no free space in the write buffer 21, the master table 22 and the master log 23 are referred to, data is evicted from the write buffer 21 and written to the NAND 10. The master table 22 or the master log 23 is updated in accordance with data writing to the write buffer 21 and data writing to the NAND 10.

  In the SSD 100, for example, when data of the same LBA is overwritten, the read / write control unit 31 executes the following processing. It is assumed that valid data having a block size is stored at the logical address A1, and the block B1 is used as a storage area. When a command for overwriting update data having a block size of the logical address A1 is received from the host 1, one free block (referred to as block B2) that is an unassigned block not including valid data is secured. Write the data received from the host 1 to the free block. Thereafter, the management information relating the logical address A1 and the block B2 is updated. As a result, the block B2 contains valid data inside and becomes an active block which is a block to which a use is assigned, and the data stored in the block B1 becomes invalid, so the block B1 becomes a free block.

  As described above, in the SSD 100, even if the data has the same logical address A1, the block used as the actual recording area changes every time writing is performed. Note that, in writing update data with a block size, the write destination block always changes, but with update data writing with a block size less than that, update data may be written in the same block. For example, when page data smaller than the block size is updated, old page data having the same logical address in the block is invalidated, and the latest page data newly written is managed as a valid page. When all the data in the block is invalidated, the block is released as a free block.

The table manager 32
A process of transferring the backup management table (snapshot) 12 stored in the NAND 10 to the RAM 20 as a master table 22 at startup,
When a snapshot condition is satisfied, such as when a normal power-off sequence occurs or when the storage area of the master log 23 is insufficient, a snapshot process for storing the master table 22 on the RAM 20 as a snapshot in the NAND 10 is executed. To do.

The log management unit 33
A process of accumulating and storing in the master log 23 a difference log, which is difference information before and after updating the master table 22, when an event that should update the master table 22 occurs;
The master log 23 on the RAM 20 is stored in the backup log of the NAND 10 when a predetermined commit condition such as when the amount of the master log 23 reaches a certain value or when the updated management tables are consistent is reached. The above-described commit process for reflecting the master log 23 in the master table 22 is executed in addition to the non-volatile log) 13 in order.

  When a snapshot or commit is performed, the master log 23 accumulated on the RAM 20 is invalidated.

  Next, snapshots will be described in more detail. FIG. 3 shows a comparative example of the snapshot storage method. In FIG. 3, the root pointer RP (lower left hatched portion) is stored in the page of the root block RB which is a predetermined block of the NAND 10, and the second pointer SP (lower left hatched) is stored in the second block SB which is the block indicated by the root pointer RP. And a backup management table (snapshot) 12 is stored in the data block DB, which is a block indicated by the second pointer SP. In this pointer method, first, the root pointer RP is read from the flash memory, the second pointer SP that is data at the position on the NAND 10 pointed to by the root pointer RP is read, and the snap that is the data at the position on the NAND 10 pointed to by the second pointer SP. Management information is acquired by reading the shot 12.

  FIG. 3 shows one page in which one section in the block is a NAND write unit. Since the pointer information stored in the root block RB and the second block SB is the address of the next block, several tens of bytes are sufficient. On the other hand, the page size of the NAND 10 is 8 KiB or 16 KiB, and each page includes a lot of useless unwritten areas MM where information is not written.

  Therefore, in the present embodiment, as shown in FIG. 4, each page of the root block RB and the second block SB has pointer information (root pointer RP, second pointer SP), and the storage position of the page in the pointer information. A part of the backup management table (snapshot) 12 that is the data to be pointed is stored. Hereinafter, the snapshot storage system of this embodiment will be described in detail with reference to FIG.

  As shown in FIG. 4, in this embodiment, in order to prevent exhaustion of the root block RB due to an increase in the number of rewrites, the pointer to the data area is managed in two stages using the root block RB and the second block SB. As the root block RB, a fixed area of the NAND 10 (a predetermined block determined in advance and the controller 30 recognizes the block address) is used. Information indicating the block address of the second block SB is written in the root pointer RP, and the root pointer RP is first written in the first page of the root block RB. When the second block SB to which the second pointer SP is written becomes full and the next different block is used as the second block SB, the root pointer RP is written to the next page of the first page of the root block RB. Such a process is repeated. Therefore, the page immediately before the unwritten page in the root block RB is the latest root pointer RP.

  Any block of the NAND 10 is used as the second block SB. Information indicating the position on the NAND 10 storing the backup management table (snapshot) 12 is written in the second pointer SP, and the second pointer SP is first written in the first page of the second block SB. That is, as the pointer information to which the second pointer SP points, the storage position of the data block DB in which the backup management table (snapshot) 12 is stored (the block address indicating the storage start position of the snapshot 12 + the page address) is used. Information indicating the block identification information).

  When the storage position on the NAND 10 of the backup management table (snapshot) 12 is changed, the second pointer SP is written to the page following the first page of the second block SB. Such a process is repeated. Therefore, the page immediately before the unwritten page in the second block SB is the latest second pointer SP. When the second block SB in which the second pointer SP is written becomes full, another block is used as the second block SB. At this time, as described above, the route pointer RP is updated, and the updated data is written to the next page of the current page.

  As the data block DB in which the backup management table (snapshot) 12 is stored, any one or more blocks of the NAND 10 are used. If an unwritten page remains in the block after saving the snapshot, the next snapshot may be saved from this unwritten page as shown in FIG. 5, or as shown in FIG. When the commit condition is satisfied, the log may be saved from this unwritten page.

  In the case of FIG. 4, the snapshot is stored in the root block RB and the second block SB in addition to the data block DB. That is, a part of the snapshot is always saved in the unwritten area in the page where the latest second pointer SP of the second block SB is saved. Since the pointer has a fixed size, it is possible to identify the pointer storage portion and the snapshot storage portion in the page.

  Further, in the unwritten area in the page in which the latest root pointer RP of the root block RB is saved, the snapshot is only taken when the second pointer SB for saving the second pointer SP is changed and the root pointer RP is changed. A part of is saved. A part of the snapshot saved in the root block RB is used as a valid snapshot only when the second block SB is changed and the second pointer SP and a part of the snapshot are saved on the first page of the second block SB. When the second pointer SP is stored after the next page of the second block SB, it is treated as an invalid snapshot.

  In this embodiment, when reading a snapshot stored in the NAND 10, the controller 30 first reads a page including the root pointer RP from the root block RB, and a second block SB that is a block on the NAND 10 indicated by the root pointer RP. The page immediately before the unused page is read to obtain the page including the second pointer SP, and the data at the position on the NAND 10 pointed to by the second pointer SP is read to obtain the snapshot 12 in the data block DB. Further, the controller combines the snapshot 12 in the data block DB and the snapshot 12 in the page including the second pointer SP, and if the snapshot 12 in the page including the root pointer RP is valid, By combining the snapshots 12 in the page including the root pointer RP, the entire snapshot is acquired.

  Note that a part of the snapshot may not be stored in the root block RB, and a part of the snapshot may be stored only in the second block SB.

  As described above, in this embodiment, in the root block RB and the second block SB, a part of the snapshot is saved in the empty area of the page where the pointer information is saved, thereby effectively using the storage area in which the pointer information is stored. Therefore, it is possible to reduce the amount of snapshot data to be stored in the data block, thereby making it possible to effectively use the block and prevent wear of the block. In addition, since the number of pages used for storage in the data block is reduced, the time required for writing and reading the snapshot is reduced accordingly.

  When the writing unit in the block is different from the page, the pointer information and a part of the snapshot may be saved for each writing unit. In the embodiment, the double pointer method is adopted. However, even when the single pointer method or the triple pointer method or more is adopted, a part of the snapshot is saved in the free area of the page where the pointer information is saved. What should I do?

  Although several embodiments of the present invention have been described, these embodiments are presented by way of example and are not intended to limit the scope of the invention. These novel embodiments can be implemented in various other forms, and various omissions, replacements, and changes can be made without departing from the scope of the invention. These embodiments and modifications thereof are included in the scope and gist of the invention, and are included in the invention described in the claims and the equivalents thereof.

  1 host device, 2 host interface, 10 NAND flash memory, 11 user data storage unit, 12 backup management table, 13 backup log, 20 RAM, 21 write buffer, 22 master table, 23 master log, 30 controller, 31 read / write control Section, 32 table management section, 33 log management section.

Claims (4)

A volatile first storage unit;
A non-volatile second storage unit in which writing is performed in a predetermined writing unit and erasing is performed in block units larger than the writing unit;
The data transfer between the host device and the second storage unit is performed via the first storage unit, and the logical address designated by the host device and the storage position of the data in the second storage unit are determined. A management table including logical-physical conversion information to be associated is transferred from the second storage unit to the first storage unit at startup, and the second storage unit updates the transferred management table based on the management table while updating the transferred management table. A controller for data management;
With
The controller is
When the first condition is satisfied, the management table is saved as a snapshot from the first storage unit to the first block of the second storage unit, and a pointer indicating the storage position of the management table is set to the second A table management unit for storing a part of the management table in an unwritten area in the writing unit in the second block in which the pointer is stored, and storing in the writing unit in the second block of the storage unit; A memory system characterized by that. The second block in which the pointer is stored is
A third block in which a second pointer indicating the storage position of the management table is stored; and a fourth block in which a root pointer indicating the storage position of the second pointer is stored;
The table management unit
Of the write unit in the third block in which the second pointer is stored and the write unit in the fourth block in which the root pointer is stored, at least in the write unit in the third block in which the second pointer is stored. The memory system according to claim 1, wherein a part of the management table is stored in a write area.   The memory system according to claim 1, wherein the next snapshot is additionally recorded from an unwritten area of the first block in which the snapshot is stored. The controller is
When a change occurs in the management table, a log that is difference information before and after the change is stored in the first storage unit, and when the second condition is satisfied, the log is transferred from the first storage unit to the first storage unit. The memory system according to claim 1, further comprising: a log management unit that additionally records an unwritten area of the first block in which the snapshot in the second storage unit is stored.

Images