littlefs原理分析#[五]文件读写-开源基础软件社区-51CTO.COM

// Configuration provided during initialization of the littlefs
struct lfs_config {
    ...

    // Read a region in a block. Negative error codes are propogated
    // to the user.
    int (*read)(const struct lfs_config *c, lfs_block_t block,
            lfs_off_t off, void *buffer, lfs_size_t size);

    // Program a region in a block. The block must have previously
    // been erased. Negative error codes are propogated to the user.
    // May return LFS_ERR_CORRUPT if the block should be considered bad.
    int (*prog)(const struct lfs_config *c, lfs_block_t block,
            lfs_off_t off, const void *buffer, lfs_size_t size);

    // Erase a block. A block must be erased before being programmed.
    // The state of an erased block is undefined. Negative error codes
    // are propogated to the user.
    // May return LFS_ERR_CORRUPT if the block should be considered bad.
    int (*erase)(const struct lfs_config *c, lfs_block_t block);

    // Sync the state of the underlying block device. Negative error codes
    // are propogated to the user.
    int (*sync)(const struct lfs_config *c);

    ...
};

lfs_bd_read(lfs_t *lfs,
|       const lfs_cache_t *pcache, lfs_cache_t *rcache, lfs_size_t hint,
|       lfs_block_t block, lfs_off_t off,
|       void *buffer, lfs_size_t size) 
|   // 1. 检查是否已读完，未读完则继续步骤，否则结束
|-> while (size > 0) ...
|
|   // 2. 如果pcache中有缓存对应数据，则从pcache中读
|-> if (pcache && block == pcache->block &&
|           off < pcache->off + pcache->size) {
|       if (off >= pcache->off) {
|           // is already in pcache?
|           diff = lfs_min(diff, pcache->size - (off-pcache->off));
|           memcpy(data, &pcache->buffer[off-pcache->off], diff);
|
|           data += diff;
|           off += diff;
|           size -= diff;
|           continue;
|       }
|       // pcache takes priority
|       diff = lfs_min(diff, pcache->off-off);
|   }
|
|   // 3. 如果rcache中有缓存对应数据，则从rcache中读
|-> if (block == rcache->block &&
|           off < rcache->off + rcache->size) {
|       if (off >= rcache->off) {
|           // is already in rcache?
|           diff = lfs_min(diff, rcache->size - (off-rcache->off));
|           memcpy(data, &rcache->buffer[off-rcache->off], diff);
|
|           data += diff;
|           off += diff;
|           size -= diff;
|           continue;
|       }
|       // rcache takes priority
|       diff = lfs_min(diff, rcache->off-off);
|   }
|
|   // 4. 如果未命中cache且size大于等于read_size，
|   // 则读取内容大小超过cache一次加载的大小，此时从块中读
|-> if (size >= hint && off % lfs->cfg->read_size == 0 &&
|            size >= lfs->cfg->read_size) {
|        // bypass cache?
|        diff = lfs_aligndown(diff, lfs->cfg->read_size);
|        lfs->cfg->read(lfs->cfg, block, off, data, diff);
|
|        data += diff;
|        off += diff;
|        size -= diff;
|        continue;
|    }
|
|   // 5. 如果未命中cache且size小于read_size，则将块数据加载到rcache
|-> rcache->block = block;
|   rcache->off = lfs_aligndown(off, lfs->cfg->read_size);
|   rcache->size = lfs_min(
|           lfs_min(
|               lfs_alignup(off + hint, lfs->cfg->read_size),
|               lfs->cfg->block_size)
|           - rcache->off,
|           lfs->cfg->cache_size);
|   int err = lfs->cfg->read(lfs->cfg, rcache->block,
|           rcache->off, rcache->buffer, rcache->size);

lfs_bd_prog(lfs_t *lfs,
|       lfs_cache_t *pcache, lfs_cache_t *rcache, bool validate,
|       lfs_block_t block, lfs_off_t off,
|       const void *buffer, lfs_size_t size) 
|   // 1. 检查是否已写完，未写完则继续步骤，否则结束
|-> while (size > 0) ...
|
|   // 2. 如果pcache已准备好，则将数据复制到pcache中
|-> if (block == pcache->block &&
|           off >= pcache->off &&
|           off < pcache->off + lfs->cfg->cache_size) {
|       // already fits in pcache?
|       lfs_size_t diff = lfs_min(size,
|               lfs->cfg->cache_size - (off-pcache->off));
|       memcpy(&pcache->buffer[off-pcache->off], data, diff);
|
|       data += diff;
|       off += diff;
|       size -= diff;
|
|   // 2.1 如果pcache已满，则进行flush 
|-> if (pcache->size == lfs->cfg->cache_size) {
|       // eagerly flush out pcache if we fill up
|       lfs_bd_flush(lfs, pcache, rcache, validate);
|       continue;
|   }
|
|   // 3. 如果pcache未准备好，则准备pcache
|-> pcache->block = block;
|   pcache->off = lfs_aligndown(off, lfs->cfg->prog_size);
|   pcache->size = 0;