littlefs介绍

1、littlefs主要用在微控制器和flash上，是一种嵌入式文件系统。主要有3个特点：

1)、掉电恢复

在写入时即使复位或者掉电也可以恢复到上一个正确的状态。

2)、擦写均衡

有效延长flash的使用寿命

3)、有限的RAM/ROM

节省ROM和RAM空间

 

2、已有的文件系统

1）非掉电恢复，基于block的文件系统，常见的有FAT和EXT2。这两个文件系统在写入文件时是原地更新的，不具备非掉电恢复的特性。

2) 日志式的文件系统，比如JFFS,YAFFS等，具备掉电恢复的特性。但是这几个系统消耗了太多的RAM，且性能较低。

3) EXT4和COW类型的btrfs具有良好的恢复性和读写性能，但是需要的资源过多，不适合小型的嵌入式系统。

 

    littlefs综合了日志式文件系统和COW文件系统的优点。从sub-block的角度来看，littlefs是基于日志的文件系统，提供了metadata的原子更新；从super-block的角度，littlefs是基于block的COW树。

----------------------------------------------------------------------------------------------------------------------------------------------------------------------

移植LittleFs

MT2503的板子外挂8Mbit的SPI Flash，本打算移植Fatfs，但Fatfs并不支持Wear leveling，后发现LittleFs，一个专门为单片机设计的文件系统，并且支持fail-safe。

详细介绍：https://os.mbed.com/blog/entry/littlefs-high-integrity-embedded-fs/
LittleFs Github https://github.com/ARMmbed/littlefs

LittleFs的移植很简单，只需实现Flash的读、写和擦除基本操作即可，官方例子如下：

1.  
   #include "lfs.h"
2.  
    
3.  
   // variables used by the filesystem
4.  
   lfs_t lfs;
5.  
   lfs_file_t file;
6.  
    
7.  
   // configuration of the filesystem is provided by this struct
8.  
   const struct lfs_config cfg = {
9.  
   // block device operations
10.  
    .read = user_provided_block_device_read,
11.  
    .prog = user_provided_block_device_prog,
12.  
    .erase = user_provided_block_device_erase,
13.  
    .sync = user_provided_block_device_sync,
14.  
     
15.  
    // block device configuration
16.  
    .read_size = 16,
17.  
    .prog_size = 16,
18.  
    .block_size = 4096,
19.  
    .block_count = 128,
20.  
    .lookahead = 128,
21.  
    };
22.  
     
23.  
    // entry point
24.  
    int main(void) {
25.  
    // mount the filesystem
26.  
    int err = lfs_mount( &lfs, &cfg);
27.  
     
28.  
    // reformat if we can't mount the filesystem
29.  
    // this should only happen on the first boot
30.  
    if (err) {
31.  
    lfs_format( &lfs, &cfg);
32.  
    lfs_mount( &lfs, &cfg);
33.  
    }
34.  
     
35.  
    // read current count
36.  
    uint32_t boot_count = 0;
37.  
    lfs_file_open( &lfs, &file, "boot_count", LFS_O_RDWR | LFS_O_CREAT);
38.  
    lfs_file_read( &lfs, &file, &boot_count, sizeof(boot_count));
39.  
     
40.  
    // update boot count
41.  
    boot_count += 1;
42.  
    lfs_file_rewind( &lfs, &file);
43.  
    lfs_file_write( &lfs, &file, &boot_count, sizeof(boot_count));
44.  
     
45.  
    // remember the storage is not updated until the file is closed successfully
46.  
    lfs_file_close( &lfs, &file);
47.  
     
48.  
    // release any resources we were using
49.  
    lfs_unmount( &lfs);
50.  
     
51.  
    // print the boot count
52.  
    printf("boot_count: %d\n", boot_count);
53.  
    }

已经实现的Flash驱动声明：

1.  
   void flash_read_block(kal_uint32 addr, kal_uint8 *buff, kal_uint32 len);
2.  
   void flash_write_block(kal_uint32 addr, kal_uint8 *buff, kal_uint32 len);
3.  
   void flash_erase_block(kal_uint32 addr);

操作接口配置：

1.  
   static int _block_read(const struct lfs_config *c, lfs_block_t block, lfs_off_t off, void *buffer, lfs_size_t size)
2.  
   {
3.  
   flash_read_block(block * c->block_size + off, (kal_uint8 *)buffer, (kal_uint32)size);
4.  
   return 0;
5.  
   }
6.  
   static int _block_prog(const struct lfs_config *c, lfs_block_t block, lfs_off_t off, const void *buffer, lfs_size_t size)
7.  
   {
8.  
   flash_write_block(block * c->block_size + off, (kal_uint8 *)buffer, (kal_uint32)size);
9.  
   return 0;
10.  
    }
11.  
    static int _block_erase(const struct lfs_config *c, lfs_block_t block)
12.  
    {
13.  
    flash_erase_block(block * c->block_size);
14.  
    return 0;
15.  
    }
16.  
    static int _block_sync(const struct lfs_config *c)
17.  
    {
18.  
    return 0;
19.  
    }
20.  
     
21.  
    const struct lfs_config cfg = {
22.  
    // block device operations
23.  
    .read = _block_read,
24.  
    .prog = _block_prog,
25.  
    .erase = _block_erase,
26.  
    .sync = _block_sync,
27.  
     
28.  
    // block device configuration
29.  
    .read_size = 16,
30.  
    .prog_size = 16,
31.  
    .block_size = 4096,
32.  
    .block_count = 256,
33.  
    .lookahead = 256,
34.  
    };

编译时出现大量Error，经过折腾最终搞定。

总结了一下：
1. armcc默认不支持对结构体指定成员名称进行初始化、不支持可执行代码之后声明变量，CFLAG添加 –gnu 可以解决问题，添加方法请参考《MTK功能机MMI，添加GNU特性》；
2. LittleFs需要提供系统的malloc, free函数接口。

 

原文地址：http://www.noblock.cn/?p=183

-------------------------------------------------------------------------------------------------------------------------------------------------------------

littlefs 重要的数据结构

1、文件类型

1. // File types

2. enum lfs_type {

3. // file types

4. LFS_TYPE_REG = 0x001,

5. LFS_TYPE_DIR = 0x002,

6.  

7. // internally used types

8. LFS_TYPE_SPLICE = 0x400,

9. LFS_TYPE_NAME = 0x000,

10. LFS_TYPE_STRUCT = 0x200,

11. LFS_TYPE_USERATTR = 0x300,

12. LFS_TYPE_FROM = 0x100,

13. LFS_TYPE_TAIL = 0x600,

14. LFS_TYPE_GLOBALS = 0x700,

15. LFS_TYPE_CRC = 0x500,

16.  

17. // internally used type specializations

18. LFS_TYPE_CREATE = 0x401,

19. LFS_TYPE_DELETE = 0x4ff,

20. LFS_TYPE_SUPERBLOCK = 0x0ff,

21. LFS_TYPE_DIRSTRUCT = 0x200,

22. LFS_TYPE_CTZSTRUCT = 0x202,

23. LFS_TYPE_INLINESTRUCT = 0x201,

24. LFS_TYPE_SOFTTAIL = 0x600,

25. LFS_TYPE_HARDTAIL = 0x601,

26. LFS_TYPE_MOVESTATE = 0x7ff,

27.  

28. // internal chip sources

29. LFS_FROM_NOOP = 0x000,

30. LFS_FROM_MOVE = 0x101,

31. LFS_FROM_USERATTRS = 0x102,

32. };

2、文件打开时的标志

1. // File open flags

2. enum lfs_open_flags {

3. // open flags

4. LFS_O_RDONLY = 1, // Open a file as read only

5. LFS_O_WRONLY = 2, // Open a file as write only

6. LFS_O_RDWR = 3, // Open a file as read and write

7. LFS_O_CREAT = 0x0100, // Create a file if it does not exist

8. LFS_O_EXCL = 0x0200, // Fail if a file already exists

9. LFS_O_TRUNC = 0x0400, // Truncate the existing file to zero size

10. LFS_O_APPEND = 0x0800, // Move to end of file on every write

11.  

12. // internally used flags

13. LFS_F_DIRTY = 0x010000, // File does not match storage

14. LFS_F_WRITING = 0x020000, // File has been written since last flush

15. LFS_F_READING = 0x040000, // File has been read since last flush

16. LFS_F_ERRED = 0x080000, // An error occured during write

17. LFS_F_INLINE = 0x100000, // Currently inlined in directory entry

18. LFS_F_OPENED = 0x200000, // File has been opened

19. };

3、文件seek时的标志

1. // File seek flags

2. enum lfs_whence_flags {

3. LFS_SEEK_SET = 0, // Seek relative to an absolute position

4. LFS_SEEK_CUR = 1, // Seek relative to the current file position

5. LFS_SEEK_END = 2, // Seek relative to the end of the file

6. };

4、lfs的配置参数

1. // Configuration provided during initialization of the littlefs

2. struct lfs_config {

3. // Opaque user provided context that can be used to pass

4. // information to the block device operations

5. /* 这个参数主要是传递给block驱动代码 */

6. void *context;

7.  

8. /* 从设备读数据 */

9. int (*read)(const struct lfs_config *c, lfs_block_t block,

10. lfs_off_t off, void *buffer, lfs_size_t size);

11.  

12. /* 向设备写入数据，block设备在写入前必须已经erase了 */

13. int (*prog)(const struct lfs_config *c, lfs_block_t block,

14. lfs_off_t off, const void *buffer, lfs_size_t size);

15.  

16. /* 擦除block */

17. int (*erase)(const struct lfs_config *c, lfs_block_t block);

18.  

19. /* sync块设备的状态 */

20. int (*sync)(const struct lfs_config *c);

21.  

22. /* 最小的读取单元大小 */

23. lfs_size_t read_size;

24.  

25. /* 最小的写入数据单元大小，也是数据metadata pair中tag的对齐尺寸 */

26. lfs_size_t prog_size;

27.  

28. /* 最小的擦除单元大小。可以比flash的实际block尺寸大。但是对于ctz类型的文件，block size是最小的分配单元。同时block size必须是

29. read size和program size的倍数，block size会存储在superblock中 */

30. lfs_size_t block_size;

31.  

32. /* 属于文件系统的block数量，block count会存储在superblock中 */

33. lfs_size_t block_count;

34.  

35. /* 文件系统进行垃圾回收时的block的擦除次数，推荐取值100-1000.值越大垃圾回收的次数越少，性能越好 */

36. int32_t block_cycles;

37.  

38. /* littlefs需要一个read cache，一个program cache，每个文件也需要一个cache。cache越大性能越好，会减少会flash的访问次数，

39. cache必须是block的read size和program size的倍数，同时是block size的因数 */

40. lfs_size_t cache_size;

41.  

42. /* lookahead buffer的尺寸。lookahead buffer主要是block alloctor在分配块的时候用到。lookahead size必须是8的倍数，

43. 因为它是采用bitmap的形式存储的 */

44. lfs_size_t lookahead_size;

45.  

46. /* cache size大小的read buffer，可以静态分配也可以动态分配 */

47. void *read_buffer;

48.  

49. /* cache size大小的program buffer，可以静态分配也可以动态分配 */

50. void *prog_buffer;

51.  

52. /* lookahead_size大小的lookahead buffer，且是32-bit对齐的，即可以静态分配也可以动态分配 */

53. void *lookahead_buffer;

54.  

55. /* 文件名的最大长度，这个值会存储在superblock中 */

56. lfs_size_t name_max;

57.  

58. /* 文件的最大长度，存储在superblock中 */

59. lfs_size_t file_max;

60.  

61. /* 用户属性的最大长度 */

62. lfs_size_t attr_max;

63. };

5、文件信息

1. // File info structure

2. struct lfs_info {

3. // Type of the file, either LFS_TYPE_REG or LFS_TYPE_DIR 普通文件或者目录

4. uint8_t type;

5.  

6. // Size of the file, only valid for REG files. Limited to 32-bits. 对于普通文件才有意义

7. lfs_size_t size;

8.  

9. // Name of the file stored as a null-terminated string. Limited to

10. // LFS_NAME_MAX+1, which can be changed by redefining LFS_NAME_MAX to

11. // reduce RAM. LFS_NAME_MAX is stored in superblock and must be

12. // respected by other littlefs drivers.

13. /* 字符串形式的文件名 */

14. char name[LFS_NAME_MAX+1];

15. };

6、用户属性

1. struct lfs_attr {

2. /* 属性类型 */

3. uint8_t type;

4.  

5. /* 存储属性的buffer */

6. void *buffer;

7.  

8. /* 属性的长度，最大值为LFS_ATTR_MAX */

9. lfs_size_t size;

10. };

7、文件open时的配置

1. struct lfs_file_config {

2. /* cache size长度的buffer，可以静态分配也可以动态分配 */

3. void *buffer;

4.  

5. /* 用户属性，读文件时，attr存储从flash上读取的文件用户属性，写入文件时，attr存放用户指定的文件属性并会写入到flash中 */

6. struct lfs_attr *attrs;

7.  

8. /* 用户属性的长度 */

9. lfs_size_t attr_count;

10. };

8、lfs_cache结构

1. typedef struct lfs_cache {

2. lfs_block_t block; // cache中的数据属于的block

3. lfs_off_t off; // cache中的数据在block上的偏移地址

4. lfs_size_t size; // cache的大小

5. uint8_t *buffer; // cache数据的存放地址

6. } lfs_cache_t;

9、lfs_mdir结构，代表metadata pair,dir本身所在的block

1. typedef struct lfs_mdir {

2. lfs_block_t pair[2]; // dir的metadata pair所在的block

3. uint32_t rev; // metadata pair的revision

4. lfs_off_t off; // tag的偏移地址

5. uint32_t etag;

6. uint16_t count;

7. bool erased;

8. bool split; // metadata pair是否是链表

9. lfs_block_t tail[2]; // 用于metadata pair链表

10. } lfs_mdir_t;

10、lfs目录结构

1. // littlefs directory type

2. typedef struct lfs_dir {

3. struct lfs_dir *next; // 指向子目录

4. uint16_t id;

5. uint8_t type; // LFS_TYPE_DIR

6. lfs_mdir_t m; // 代表dir的metadata pair

7. lfs_off_t pos; // 在目录中的当前位置，主要用在seek，tell和rewind操作中

8. lfs_block_t head[2];

9. } lfs_dir_t;

11、lfs文件类型

1. // littlefs file type

2. typedef struct lfs_file {

3. struct lfs_file *next;

4. uint16_t id; // metadata tag中的id，在文件open时获取

5. uint8_t type; // LFS_TYPE_REG 或者 LFS_TYPE_DIR

6. lfs_mdir_t m; // 文件所在的目录的metadata pair

7.  

8. struct lfs_ctz {

9. lfs_block_t head;

10. lfs_size_t size;

11. } ctz; // 指向大文件的CTZ skip-list。对于小文件则直接inline了，无需CTZ skip-list

12.  

13. uint32_t flags; // lfs_open_flags中的值

14. lfs_off_t pos; // 文件访问时的偏移

15. lfs_block_t block; // file当前的block

16. lfs_off_t off; // 在block内的offset

17. lfs_cache_t cache; // 文件访问时的cache

18.  

19. const struct lfs_file_config *cfg; // 文件open时的配置参数，包含一个buffer以及用户属性

20. } lfs_file_t;

12、lfs superblock结构

1. typedef struct lfs_superblock {

2. uint32_t version; // 文件系统的版本号

3. lfs_size_t block_size; // 文件系统的block size，和flash的block size不一定相同

4. lfs_size_t block_count; // 文件系统包含的block数量，每个block的大小等于上面的block size

5. lfs_size_t name_max; // 文件名的最大长度

6. lfs_size_t file_max; // 文件的最大长度

7. lfs_size_t attr_max; // 用户属性的最大长度

8. } lfs_superblock_t;

13、lfs文件系统类型结构

1. // The littlefs filesystem type

2. typedef struct lfs {

3. lfs_cache_t rcache; // read cache

4. lfs_cache_t pcache; // program cache

5. lfs_block_t root[2]; // 根目录所在的block

6. struct lfs_mlist {

7. struct lfs_mlist *next; // 指向下一个节点

8. uint16_t id; // metadata pair的id

9. uint8_t type; // metadata pair的类型

10. lfs_mdir_t m; // metadata pair

11. } *mlist; // metadata pair list

12. uint32_t seed; // block alloctor的随机数生成的seed

13.  

14. struct lfs_gstate {

15. uint32_t tag;

16. lfs_block_t pair[2];

17. } gstate, gpending, gdelta; // 用于目录操作sync的global state，

18.  

19. struct lfs_free {

20. lfs_block_t off; // 记录lookahead buffer中起始block的偏移

21. lfs_block_t size; // lookahead buffer中block的数量，注意lookahead采用的是bitmap的形式，因此size=8*lookahead_size

22. lfs_block_t i; // lookahead buffer内部的偏移地址

23. lfs_block_t ack; // 剩余block的数量，初始值为block count，如果该值为0，表示已经没有free block了

24. uint32_t *buffer; // buffer的长度为lookahead size

25. } free; // lookahead buffer，用于分配free block

26.  

27. const struct lfs_config *cfg; // 文件系统的配置参数

28. lfs_size_t name_max; // 文件名的最大长度，和superblock中的name_max值相同

29. lfs_size_t file_max; // 文件的最大长度，和superblock中的file_max值相同

30. lfs_size_t attr_max; // 用户属性的最大长度，和superblock中的attr_max值相同

31. } lfs_t;

----------------------------------------------------------------------------------------------------------------------------------------------------------------

小型文件系统FatFS和LittleFS对比和区别

对于许多物联网设备而言，拥有一个小型且具有弹性的文件系统至关重要。

在MCU上运行的文件系统不多，绝大部分人应该知道FatFS这个文件系统，今天就给大家讲讲FatFS和LittleFS的内容，以及他们之间的一些差异。

一、文件系统FatFS

FatFs是一个通用的文件系统(FAT/exFAT)模块，用于在小型嵌入式系统中实现FAT文件系统。

网址：

http://elm-chan.org/fsw/ff/00index_e.html

 

FatFs组件的编写遵循ANSI C(C89)，完全分离于磁盘 I/O 层,因此不依赖于硬件平台。它可以嵌入到资源有限的微控制器中，如 8051, PIC, AVR, ARM, Z80, RX等等，不需要做任何修改。

---来自百度百科

特征

a.DOS/ Windows兼容的FAT/exFAT文件系统。

b.平台无关，容易移植。

c.程序代码和工作区的占用空间非常小。

d.支持以下各种配置选项：

• ANSI / OEM或Unicode中的长文件名。

• exFAT文件系统，64位LBA和GPT可存储大量数据。

• RTOS的线程安全。

• 多个卷（物理驱动器和分区）。

• 可变扇区大小。

• 多个代码页，包括DBCS。

• 只读，可选API，I / O缓冲区等...

如果你会使用STM32CubeMX，想要使用FatFS非常容易，轻松几步就能将STM32“变成”一个U盘。

二、文件系统Littlefs

知道Littlefs文件系统的人相对比较少，但是如果使用过Mbed OS系统的人绝大部分都应该知道。

Mbed OS是Arm公司针对Cortex-M系列处理器，面向IoT开发的一套免费、开源开源嵌入式操作系统，专门为物联网中的“things”而设计。

而Littlefs只是Mbed其中的一部分内容，如下框图：

源码地址：

https://github.com/armmbed/mbed-littlefs

Littlefs特点：

• 占用资源小：物联网设备受到ROM和RAM的限制。

• 断电恢复能力：要求文件系统保持一致，并将数据刷新到底层存储。

• 平均磨损：通常情况下，存储支持每块数量有限的擦除，因此使用整个存储设备对于可靠性非常重要。

用法也挺简单，参看官方例程：

1.  
   #include "LittleFileSystem2.h"
2.  
   #include "SPIFBlockDevice.h"
3.  
    
4.  
    
5.  
   // Physical block device, can be any device that supports the BlockDevice API
6.  
   SPIFBlockDevice bd(PTE2, PTE4, PTE1, PTE5);
7.  
    
8.  
    
9.  
   // Storage for the littlefs
10.  
    LittleFileSystem2 fs("fs");
11.  
     
12.  
     
13.  
    // Entry point
14.  
    int main() {
15.  
    // Mount the filesystem
16.  
    int err = fs.mount(&bd);
17.  
    if (err) {
18.  
    // Reformat if we can't mount the filesystem,
19.  
    // this should only happen on the first boot
20.  
    LittleFileSystem2::format(&bd);
21.  
    fs.mount(&bd);
22.  
    }
23.  
     
24.  
     
25.  
    // Read the boot count
26.  
    uint32_t boot_count = 0;
27.  
    FILE *f = fopen( "/fs/boot_count", "r+");
28.  
    if (!f) {
29.  
    // Create the file if it doesn't exist
30.  
    f = fopen( "/fs/boot_count", "w+");
31.  
    }
32.  
    fread(&boot_count, sizeof(boot_count), 1, f);
33.  
     
34.  
     
35.  
    // Update the boot count
36.  
    boot_count += 1;
37.  
    rewind(f);
38.  
    fwrite(&boot_count, sizeof(boot_count), 1, f);
39.  
     
40.  
     
41.  
    // Remember that storage may not be updated until the file
42.  
    // is closed successfully
43.  
    fclose(f);
44.  
     
45.  
     
46.  
    // Release any resources we were using
47.  
    fs.unmount();
48.  
     
49.  
     
50.  
    // Print the boot count
51.  
    printf("boot_count: %ld\n", boot_count);
52.  
    }

三、文件系统对比

每一种产物都有它存在的价值，文件系统也同样如此，各有各的优缺点，下面简单罗列几点它们的区别。

1.资源RAM / ROM大小

Littlefs是Mbed OS中的高完整性嵌入式文件系统，经过优化可与RAM和ROM有限的MCU一起使用。

Littlefs高度集成的嵌入式文件系统使用比FAT少的13K ROM和少于4K的RAM。

2.失电恢复能力

littlefs具有强大的copy-on-write保证，并且磁盘上的存储总是保持有效状态，可能有随机电源故障的系统适合该文件系统。

3.磨损均衡

嵌入式设备使用的大多数存储芯片都支持每个扇区有限的擦除集，如果没有均衡，则嵌入式设备的寿命可能会受到影响。

参考来源：

https://os.mbed.com/blog/entry/littlefs-high-integrity-embedded-fs/