Shulou(Shulou.com)06/02 Report--

Today, I will talk to you about how to use yaffs_GetTnode to map file addresses, many people may not know much about it. In order to make you understand better, the editor summarized the following content for you. I hope you can get something according to this article.

When the yaffs file system updates the file data, it will assign a new chunk, that is, the same file offset address, the storage address on the corresponding flash is different before and after the data on that address is updated. So, how to determine the flash storage address based on the offset address within the file? The easiest way to think of is to maintain a mapping table in memory. Because the basic storage unit of flash is chunk, this problem can be solved as long as the file offset described by chunk is used as the table index and the flash chunk serial number is used as the table content. But this method has several problems, the first is to do the seek operation, to start from the table item 0 in order to search, for large files will consume a lot of time; secondly, in the establishment of the mapping table, can not predict file size changes, so it is possible to frequently release allocated memory in subsequent operations to change the table length, resulting in memory fragments. The solution of yaffs is to split the large mapping table into several small tables of equal length, and organize these small tables into a tree structure for easy management. Let's first look at the definition of the small watch:

Struct yaffs_tnode {

Struct yaffs_tnode * NTNODES_INTERNAL [YAFFs _ NTNODES_INTERNAL]

}

YAFFS_NTNODES_INTERNAL is defined as (YAFFS_NTNODES_LEVEL0 / 2), while YAFFS_NTNODES_LEVEL0 is defined as 16, so this is actually an array of pointers of length 8. Whether it is leaf node or non-leaf node, it is this structure. When the node is a non-leaf node, each element in the array points to the next child node; when the node is a leaf node, the array is split into 16 short integers of 16 bits long (with exceptions, as we'll see later), which is where the file contents are stored on the flash (that is, the chunk sequence number). As for how to find the corresponding flash storage location through the intra-file offset, it has been explained in the document attached to the source code (Development/yaffs/Documentation/yaffs-notes2.html), so I won't rap here. Let's look at the specific functions.

For ease of writing, the pointer array yaffs_Tnode is called "a set" Tnode, and each element in the array is called "a" Tnode. Each node in the tree is a "set" of Tnode.

Let's first look at the allocation of nodes in the mapping tree.

Struct yaffs_tnode * yaffs_get_tnode (struct yaffs_dev * dev)

{

Struct yaffs_tnode * tn = yaffs_alloc_raw_tnode (dev)

If (tn) {

Memset (tn, 0, dev- > tnode_size)

Dev- > naughtnodescards +

}

Dev- > checkpoint_blocks_required = 0ram * force recalculation * /

Return tn

}

Call yaffs_GetTnodeRaw to assign the node, and then initialize the resulting node to zero.

Static yaffs_Tnode * yaffs_GetTnodeRaw (yaffs_Device * dev)

{

Yaffs_Tnode * tn = NULL

/ * If there are none left make more * /

If (! dev- > freeTnodes) {

Yaffs_CreateTnodes (dev, YAFFS_ALLOCATION_NTNODES)

}

Currently, all free nodes form a linked list, and dev- > freeTnodes is the header of the linked list. We assume that there are no free nodes available, and we need to create a new batch of nodes through yaffs_CreateTnodes.

Static int yaffs_CreateTnodes (yaffs_Device * dev, int nTnodes)

{

.

TnodeSize = (dev- > tnodeWidth * YAFFS_NTNODES_LEVEL0) / 8

NewTnodes = YMALLOC (nTnodes * tnodeSize)

Mem = (_ _ U8 *) newTnodes

}

(in fact, the slab buffer has been added to the latest version of yaffs, which improves efficiency.) as mentioned above, the bit width of a Tnode in the leaf node defaults to 16 bits, which can represent 65536 chunk. The size of today's high-capacity flash,chunk is 2K, so by default the maximum flash space that yaffs2 can address is 128m. In order to use yaffs2 on high-capacity flash, the code author tries to solve this problem in two ways. The first method is dev- > tnodeWidth here. By increasing the bit width of a single Tnode, you can increase the maximum chunk Id; it can represent. Another means is the chunk group that we will see later. By combining several chunk into a group represented by the same id, you can also increase the chunk range that the system can address.

For the sake of simplicity, I do not consider these two cases when analyzing, so tnodeWidth takes the default value of 16 and does not consider the case of combining multiple chunk into a group. I only give a brief explanation when I encounter code related to these two situations.

In a 32-bit system, the width of the pointer is 32 bits, while the width of chunk id is 16 bits, so a group of Tnode of the same size can be used to represent N non-leaf Tnode (used as pointer) or N * 2 leaf Tnode (used as chunk id). The code is represented by YAFFS_NTNODES_INTERNAL and YAFFS_NTNODES_LEVEL0 respectively. The value of the former is 8 and the value of the latter is 16. From here we can also see what changes need to be made if yaffs2 is used in 64-bit systems. In view of the problem described in the previous paragraph, I think that when there is no shortage of memory, it is better to set the leaf node Tnode and non-leaf node Tnode to the length of a pointer. Once the required memory is allocated, the free space is grouped into a Tnode linked list:

For (I = 0; I)

Internal [0] = next

}

The first element of each set of Tnode acts as a pointer to the next set of Tnode. After the construction of the linked list is completed, the statistics are incremented and the newly obtained Tnodes is hung into a global administrative linked list yaffs_TnodeList:

Dev- > nFreeTnodes + = nTnodes

Dev- > nTnodesCreated + = nTnodes

Tnl = YMALLOC (sizeof (yaffs_TnodeList))

If (! tnl) {

T (YAFFS_TRACE_ERROR, (TSTR ("yaffs: Could not add tnodes to management list" TENDSTR)

} else {

Tnl- > tnodes = newTnodes

Tnl- > next = dev- > allocatedTnodeList

Dev- > allocatedTnodeList = tnl

}

After you go back to yaffs_GetTnodeRaw and create several new sets of Tnode, cut off the required Tnode and modify the free linked list header pointer:

If (dev- > freeTnodes) {

Tn = dev- > freeTnodes

Dev- > freeTnodes = dev- > freeTnodes- > internal [0]

Dev- > nFreeTnodes--

}

After reading the above, do you have any further understanding of how to map file addresses using yaffs_GetTnode? If you want to know more knowledge or related content, please follow the industry information channel, thank you for your support.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.