#littlefs原理分析#[三]fetch操作 原创 精华

lfs_file_rawopencfg(lfs_t *lfs, lfs_file_t *file,
|       const char *path, int flags,
|       const struct lfs_file_config *cfg) 
|   // 1. 根据路径查找对应tag和id
|   // 此时查找的为REG类型的tag，查找到的文件id存储在file->id
|-> lfs_stag_t tag = lfs_dir_find(lfs, &file->m, &path, &file->id);
|
|   // 2. 根据文件id查找文件数据对应tag
|   // 此时查找的为STRUCT类型的tag，包括inline文件和outline文件
|-> tag = lfs_dir_get(lfs, &file->m, LFS_MKTAG(0x700, 0x3ff, 0),
|       LFS_MKTAG(LFS_TYPE_STRUCT, file->id, 8), &file->ctz);
|
|-> ...
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

// 该函数用于遍历时查找匹配的tag，如打开文件时查找匹配文件的对应tag
lfs_stag_t lfs_dir_fetchmatch(lfs_t *lfs,
|       lfs_mdir_t *dir, const lfs_block_t pair[2],
|       lfs_tag_t fmask, lfs_tag_t ftag, uint16_t *id,
|       int (*cb)(void *data, lfs_tag_t tag, const void *buffer), void *data) 
|-> ...
|
|   // 如果当前遍历到的tag的类型为DELETE，且其id与tempbesttag中id相同
|   // 则将tempbesttag置为无效。
|-> if (tag == (LFS_MKTAG(LFS_TYPE_DELETE, 0, 0) |
|            (LFS_MKTAG(0, 0x3ff, 0) & tempbesttag))) {
|       tempbesttag |= 0x80000000;
|   }
|-> ...
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

int lfs_dir_fetch(lfs_t *lfs,
    lfs_mdir_t *dir, // fetch tail结果存储在dir->tail中
    const lfs_block_t pair[2] // 父目录元数据对所在块
) {
    // 调用lfs_dir_fetchmatch实现
    // 其中fmask、ftag为-1，表示不进行匹配，会fetch到元数据末尾
    return (int)lfs_dir_fetchmatch(lfs, dir, pair,
            (lfs_tag_t)-1, (lfs_tag_t)-1, NULL, NULL, NULL);
}
1.
2.
3.
4.
5.
6.
7.
8.
9.

lfs_mdir_t m = dir.m;
while (m.split) {
    lfs_dir_fetch(lfs, &m, m.tail);
}
1.
2.
3.
4.

static lfs_stag_t lfs_dir_fetchmatch(lfs_t *lfs,
|       lfs_mdir_t *dir, const lfs_block_t pair[2],
|       lfs_tag_t fmask, lfs_tag_t ftag, uint16_t *id,
|       int (*cb)(void *data, lfs_tag_t tag, const void *buffer), void *data) {
|   // 用besttag保存最佳匹配结果
|-> lfs_stag_t besttag = -1;
|
|-> ...
|
|   // 准备用于暂存每次匹配中的最佳匹配结果、更新等变量
|-> uint16_t tempcount = 0;
|   lfs_block_t temptail[2] = {LFS_BLOCK_NULL, LFS_BLOCK_NULL};
|   bool tempsplit = false;
|   lfs_stag_t tempbesttag = besttag;
|
|   // fetch主流程
|-> while (true) {
    |   // 1. 从磁盘中解析下一个tag并计算tag的CRC
    |-> lfs_bd_read(lfs,
    |           NULL, &lfs->rcache, lfs->cfg->block_size,
    |           dir->pair[0], off, &tag, sizeof(tag));
    |   crc = lfs_crc(crc, &tag, sizeof(tag));
    |   tag = lfs_frombe32(tag) ^ ptag;
    |
    |   // 2. 检查边界，当不在范围内或tag无效时跳出循环
    |-> if (!lfs_tag_isvalid(tag)) {
    |       dir->erased = (lfs_tag_type1(ptag) == LFS_TYPE_CRC &&
    |               dir->off % lfs->cfg->prog_size == 0);
    |       break;
    |   } else if (off + lfs_tag_dsize(tag) > lfs->cfg->block_size) {
    |       dir->erased = false;
    |       break;
    |   }
    |
    |   // 3. 如果tag为CRC，则检查CRC并更新最佳匹配结果
    |-> if (lfs_tag_type1(tag) == LFS_TYPE_CRC) {
        |   // 3.1 检查CRC
        |-> uint32_t dcrc;
        |   lfs_bd_read(lfs,
        |           NULL, &lfs->rcache, lfs->cfg->block_size,
        |           dir->pair[0], off+sizeof(tag), &dcrc, sizeof(dcrc));
        |   if (crc != dcrc) {
        |       dir->erased = false;
        |       break;
        |   }
        |
        |   // 3.2 更新最佳匹配结果等
        |-> besttag = tempbesttag;
        |   dir->off = off + lfs_tag_dsize(tag);
        |   dir->etag = ptag;
        |   dir->count = tempcount;
        |   dir->tail[0] = temptail[0];
        |   dir->tail[1] = temptail[1];
        |   dir->split = tempsplit;
        |
        |   // 3.3 重置CRC
        |-> crc = 0xffffffff;
        |   continue;
        }
    |
    |   // 4. 计算entry的CRC
    |-> for (lfs_off_t j = sizeof(tag); j < lfs_tag_dsize(tag); j++) {
    |       uint8_t dat;
    |       lfs_bd_read(lfs,
    |               NULL, &lfs->rcache, lfs->cfg->block_size,
    |               dir->pair[0], off+j, &dat, 1);
    |       ...
    |       crc = lfs_crc(crc, &dat, 1);
    |   }
    |
    |   // 5. 根据tag类型进行相应更新
    |-> if (lfs_tag_type1(tag) == LFS_TYPE_NAME) {
    |       // 5.1 tag为NAME类型，则根据其中id更新目录中count 
    |       // 目录中的最后一个id为count-1
    |       if (lfs_tag_id(tag) >= tempcount) {
    |           tempcount = lfs_tag_id(tag) + 1;
    |       }
    |   } else if (lfs_tag_type1(tag) == LFS_TYPE_SPLICE) {
    |       // 5.2 tag为DELETE类型，如果id和目前的最佳匹配结果对应
    |       // 则将最佳匹配结果置为无效
    |       if (tag == (LFS_MKTAG(LFS_TYPE_DELETE, 0, 0) |
    |               (LFS_MKTAG(0, 0x3ff, 0) & tempbesttag))) {
    |           tempbesttag |= 0x80000000;
    |       }
    |       ...
    |   } else if (lfs_tag_type1(tag) == LFS_TYPE_TAIL) {
    |       // 5.3 tag为TAIL类型，则更新tempsplit和temptail
    |       tempsplit = (lfs_tag_chunk(tag) & 1);
    |       lfs_bd_read(lfs,
    |               NULL, &lfs->rcache, lfs->cfg->block_size,
    |               dir->pair[0], off+sizeof(tag), &temptail, 8);
    |       ...
    |   }
    |
    |   // 6. 先用fmask和ftag参数进行初次匹配
    |-> if ((fmask & tag) == (fmask & ftag)) {
    |       // 6.1 如果匹配则调用cb回调函数进行进一步匹配 
    |       int res = cb(data, tag, &(struct lfs_diskoff){
    |               dir->pair[0], off+sizeof(tag)});
    |       ... 
    |       // 6.2 如果匹配成功则更新到最佳匹配结果 
    |       if (res == LFS_CMP_EQ) {
    |           tempbesttag = tag;
    |       } else if (...)
    |           ...
    |       }
    |   }
|
|   // 如果读到结束，则根据最佳匹配结果返回相应值
|-> if (dir->off > 0) {
|       ... 
|
|       if (lfs_tag_isvalid(besttag)) {
|           return besttag;
|       } else if (lfs_tag_id(besttag) < dir->count) {
|           return LFS_ERR_NOENT;
|       } else {
|           return 0;
|       }
|   }
|
|-> ...
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.