鸿蒙轻内核M核源码分析系列二一 03 文件系统LittleFS

2.2 文件信息数组利用

函数LfsAllocFd()设置文件信息数组元素信息。参数fileName为文件路径信息，传出参数fd为文件描述符即数组索引。遍历文件信息数组，遍历到第一个未利用的元素标志其为已利用状态，设置文件路径信息，把数组索引赋值给文件描述符fd，返回文件信息元素指针地址。如果遍历失败，返回NULL。函数LfsFreeFd()为函数LfsAllocFd()的反向利用，根据文件描述符设置对应的数组元素为未利用状态，并把路径信息等设置为NULL。
函数CheckFileIsOpen()用于检测文件是否已经打开，文件如果打开过，则表现获取过该文件的文件描述符，根据对应的fd文件描述符，可以对文件进行更多的利用。如果文件信息数组中纪录着对应的文件路径信息，则标志着该文件已经打开。函数LfsFdIsValid()用于判断文件描述符是否有效。

1. LittleFsHandleStruct *LfsAllocFd(const char *fileName, int *fd)
2. {
3.     pthread_mutex_lock(&g_FslocalMutex);
4.     for (int i = 0; i < LITTLE_FS_MAX_OPEN_FILES; i++) {
5.         if (g_handle[i].useFlag == 0) {
6.             *fd = i;
7.             g_handle[i].useFlag = 1;
8.             g_handle[i].pathName = strdup(fileName);
9.             pthread_mutex_unlock(&g_FslocalMutex);
10.             return &(g_handle[i]);
11.         }
12.     }
13.     pthread_mutex_unlock(&g_FslocalMutex);
14.     *fd = INVALID_FD;
15.     return NULL;
16. }
18. static void LfsFreeFd(int fd)
19. {
20.     pthread_mutex_lock(&g_FslocalMutex);
21.     g_handle[fd].useFlag = 0;
22.     if (g_handle[fd].pathName != NULL) {
23.         free((void *)g_handle[fd].pathName);
24.         g_handle[fd].pathName = NULL;
25.     }
27.     if (g_handle[fd].lfsHandle != NULL) {
28.         g_handle[fd].lfsHandle = NULL;
29.     }
30.     pthread_mutex_unlock(&g_FslocalMutex);
31. }
33. BOOL CheckFileIsOpen(const char *fileName)
34. {
35.     pthread_mutex_lock(&g_FslocalMutex);
36.     for (int i = 0; i < LITTLE_FS_MAX_OPEN_FILES; i++) {
37.         if (g_handle[i].useFlag == 1) {
38.             if (strcmp(g_handle[i].pathName, fileName) == 0) {
39.                 pthread_mutex_unlock(&g_FslocalMutex);
40.                 return TRUE;
41.             }
42.         }
43.     }
44.     pthread_mutex_unlock(&g_FslocalMutex);
45.     return FALSE;
46. }
48. static BOOL LfsFdIsValid(int fd)
49. {
50.     if (fd >= LITTLE_FS_MAX_OPEN_FILES || fd < 0) {
51.         return FALSE;
52.     }
53.     if (g_handle[fd].lfsHandle == NULL) {
54.         return FALSE;
55.     }
56.     return TRUE;
57. }

复制代码

2.3 挂载点文件利用信息相关利用

函数AllocMountRes()用于设置挂载点文件利用信息。参数target为挂载点名称，参数fileOps为文件利用信息。遍历每个挂载点，如果遍历到的挂载点未利用，并且挂载点名称相当，则设置其利用标志为已利用，设置目录名称，设置文件利用信息，然后返回文件利用信息指针。如果没有遍历到，返回NULL。挂载点数组g_littlefsMntName的元素默认为/a,/b,/c等，可以利用函数SetDefaultMountPath()设置指定位置的挂载点名称。

1. struct FileOpInfo *AllocMountRes(const char* target, const struct FileOps *fileOps)
2. {
3.     pthread_mutex_lock(&g_FslocalMutex);
4.     for (int i = 0; i < LOSCFG_LFS_MAX_MOUNT_SIZE; i++) {
5.         if (g_fsOp[i].useFlag == 0 && strcmp(target, g_littlefsMntName[i]) == 0) {
6.             g_fsOp[i].useFlag = 1;
7.             g_fsOp[i].fsVops = fileOps;
8.             g_fsOp[i].dirName = strdup(target);
9.             pthread_mutex_unlock(&g_FslocalMutex);
10.             return &(g_fsOp[i]);
11.         }
12.     }
14.     pthread_mutex_unlock(&g_FslocalMutex);
15.     return NULL;
16. }
18. int SetDefaultMountPath(int pathNameIndex, const char* target)
19. {
20.     if (pathNameIndex >= LOSCFG_LFS_MAX_MOUNT_SIZE) {
21.         return VFS_ERROR;
22.     }
24.     pthread_mutex_lock(&g_FslocalMutex);
25.     g_littlefsMntName[pathNameIndex] = strdup(target);
26.     pthread_mutex_unlock(&g_FslocalMutex);
27.     return VFS_OK;
28. }

复制代码

函数GetMountRes()用于获取给定挂载点在挂载点文件利用信息数组中的索引值。参数target为挂载点名称，参数mountIndex用于输出文件利用信息数组索引值。遍历每个挂载点，如果遍历到的挂载点已利用，并且挂载点名称相当，则返回相应的数组索引，否则返回NULL。

1. struct FileOpInfo *GetMountRes(const char *target, int *mountIndex)
2. {
3.     pthread_mutex_lock(&g_FslocalMutex);
4.     for (int i = 0; i < LOSCFG_LFS_MAX_MOUNT_SIZE; i++) {
5.         if (g_fsOp[i].useFlag == 1) {
6.             if (g_fsOp[i].dirName && strcmp(target, g_fsOp[i].dirName) == 0) {
7.                 *mountIndex = i;
8.                 pthread_mutex_unlock(&g_FslocalMutex);
9.                 return &(g_fsOp[i]);
10.             }
11.         }
12.     }
14.     pthread_mutex_unlock(&g_FslocalMutex);
15.     return NULL;
16. }

复制代码

函数FreeMountResByIndex()属于函数AllocMountRes()的反向利用，用于释放挂载点文件利用信息。传入参数mountIndex对应的文件利用信息标志为未利用状态，释放挂载点名称占用的内存。函数FreeMountRes()实现的功能一样，传入参数为挂载点名称。遍历每一个挂载点，如果存在和传入参数相同的挂载点，则进行释放。

1. int FreeMountResByIndex(int mountIndex)
2. {
3.     if (mountIndex < 0 || mountIndex >= LOSCFG_LFS_MAX_MOUNT_SIZE) {
4.         return VFS_ERROR;
5.     }
7.     pthread_mutex_lock(&g_FslocalMutex);
8.     if (g_fsOp[mountIndex].useFlag == 1 && g_fsOp[mountIndex].dirName != NULL) {
9.         g_fsOp[mountIndex].useFlag = 0;
10.         free(g_fsOp[mountIndex].dirName);
11.         g_fsOp[mountIndex].dirName = NULL;
12.     }
13.     pthread_mutex_unlock(&g_FslocalMutex);
15.     return VFS_OK;
16. }
18. int FreeMountRes(const char *target)
19. {
20.     pthread_mutex_lock(&g_FslocalMutex);
21.     for (int i = 0; i < LOSCFG_LFS_MAX_MOUNT_SIZE; i++) {
22.         if (g_fsOp[i].useFlag == 1) {
23.             if (g_fsOp[i].dirName && strcmp(target, g_fsOp[i].dirName) == 0) {
24.                 g_fsOp[i].useFlag = 0;
25.                 free(g_fsOp[i].dirName);
26.                 g_fsOp[i].dirName = NULL;
27.                 pthread_mutex_unlock(&g_FslocalMutex);
28.                 return VFS_OK;
29.             }
30.         }
31.     }
33.     pthread_mutex_unlock(&g_FslocalMutex);
34.     return VFS_ERROR;
35. }

复制代码

2.4 路径是否已挂载CheckPathIsMounted

函数CheckPathIsMounted()用于检查给定的路径是否已经挂载，如果挂载上把对应挂载点的文件利用信息由参数struct FileOpInfo **fileOpInfo输出。⑴处先获取路径的第一级目录的长度。⑵处遍历每一个挂载点的文件利用数组，如果文件利用处于利用状态，则实行⑶比对相应的挂载点名称和路径的第一级目录名称是否相当。如果相当，则输出文件利用信息，并返回TRUE。否则返回FALSE。

1. int GetFirstLevelPathLen(const char *pathName)
2. {
3.     int len = 1;
4.     for (int i = 1; i < strlen(pathName) + 1; i++) {
5.         if (pathName[i] == '/') {
6.             break;
7.         }
8.         len++;
9.     }
11.     return len;
12. }
14. BOOL CheckPathIsMounted(const char *pathName, struct FileOpInfo **fileOpInfo)
15. {
16.     char tmpName[LITTLEFS_MAX_LFN_LEN] = {0};
17. ⑴  int len = GetFirstLevelPathLen(pathName);
19.     pthread_mutex_lock(&g_FslocalMutex);
20.     for (int i = 0; i < LOSCFG_LFS_MAX_MOUNT_SIZE; i++) {
21. ⑵      if (g_fsOp[i].useFlag == 1) {
22.             (void)strncpy_s(tmpName, LITTLEFS_MAX_LFN_LEN, pathName, len);
23. ⑶          if (strcmp(tmpName, g_fsOp[i].dirName) == 0) {
24.                 *fileOpInfo = &(g_fsOp[i]);
25.                 pthread_mutex_unlock(&g_FslocalMutex);
26.                 return TRUE;
27.             }
28.         }
29.     }
30.     pthread_mutex_unlock(&g_FslocalMutex);
31.     return FALSE;
32. }

复制代码

3、LiteOS-M LittleFS的文件系统利用接口

快速纪录下各个利用接口，对每个接口的用途用法不再描述。可以参考之前的系列文章，《鸿蒙轻内核M核源码分析系列十九 Musl LibC》中介绍了相关的接口，那些接口会调用VFS文件系统中利用接口，然后进一步调用LFS文件利用接口。
3.1 挂载LfsMount和卸载LfsUmounts利用

挂载卸载利用包罗LfsMount、LfsUmounts等2个利用。对于函数LfsMount()，需要留意下参数const void *data，这个需要是struct lfs_config指针类型变量。⑴处在挂载文件系统之前，对输入参数进行检测。⑵处判断是否已经挂载，不允许重复挂载。⑶处设置挂载点信息，⑷处调用LFS的函数实现挂载，如果挂载失败，则实行⑸尝试格式化，然后重新挂载。
对于函数LfsUmount()，⑹处根据挂载点获取文件利用信息和挂载点索引值。⑺处调用LFS函数实现卸载，然后实行⑻释放挂载点文件利用信息。

1. int LfsMount(const char *source, const char *target, const char *fileSystemType, unsigned long mountflags,
2.     const void *data)
3. {
4.     int ret;
5.     struct FileOpInfo *fileOpInfo = NULL;
7. ⑴  if (target == NULL || fileSystemType == NULL || data == NULL) {
8.         errno = EFAULT;
9.         ret = VFS_ERROR;
10.         goto errout;
11.     }
13.     if (strcmp(fileSystemType, "littlefs") != 0) {
14.         errno = ENODEV;
15.         ret = VFS_ERROR;
16.         goto errout;
17.     }
19. ⑵  if (CheckPathIsMounted(target, &fileOpInfo)) {
20.         errno = EBUSY;
21.         ret = VFS_ERROR;
22.         goto errout;
23.     }
25.     // select free mount resource
26. ⑶  fileOpInfo = AllocMountRes(target, &g_lfsFops);
27.     if (fileOpInfo == NULL) {
28.         errno = ENODEV;
29.         ret = VFS_ERROR;
30.         goto errout;
31.     }
33. ⑷  ret = lfs_mount(&(fileOpInfo->lfsInfo), (struct lfs_config*)data);
34.     if (ret != 0) {
35. ⑸      ret = lfs_format(&(fileOpInfo->lfsInfo), (struct lfs_config*)data);
36.         if (ret == 0) {
37.             ret = lfs_mount(&(fileOpInfo->lfsInfo), (struct lfs_config*)data);
38.         }
39.     }
41.     if (ret != 0) {
42.         errno = LittlefsErrno(ret);
43.         ret = VFS_ERROR;
44.     }
46. errout:
47.     return ret;
48. }
50. int LfsUmount(const char *target)
51. {
52.     int ret;
53.     int mountIndex = -1;
54.     struct FileOpInfo *fileOpInfo = NULL;
56.     if (target == NULL) {
57.         errno = EFAULT;
58.         return VFS_ERROR;
59.     }
61. ⑹  fileOpInfo = GetMountRes(target, &mountIndex);
62.     if (fileOpInfo == NULL) {
63.         errno = ENOENT;
64.         return VFS_ERROR;
65.     }
67. ⑺  ret = lfs_unmount(&(fileOpInfo->lfsInfo));
68.     if (ret != 0) {
69.         errno = LittlefsErrno(ret);
70.         ret = VFS_ERROR;
71.     }
73. ⑻  (void)FreeMountResByIndex(mountIndex);
74.     return ret;
75. }

复制代码

3.2 文件目录利用接口

文件目录利用接口包罗LfsMkdir、LfsUnlink、LfsRmdir、LfsReaddir、LfsClosedir、LfsOpen、LfsClose等等，会进一步调用LFS的文件目录利用接口进行封装，代码比较简单，自行阅读即可，部分代码片段如下。

1. ......
2. int LfsUnlink(const char *fileName)
3. {
4.     int ret;
5.     struct FileOpInfo *fileOpInfo = NULL;
7.     if (fileName == NULL) {
8.         errno = EFAULT;
9.         return VFS_ERROR;
10.     }
12.     if (CheckPathIsMounted(fileName, &fileOpInfo) == FALSE || fileOpInfo == NULL) {
13.         errno = ENOENT;
14.         return VFS_ERROR;
15.     }
17.     ret = lfs_remove(&(fileOpInfo->lfsInfo), fileName);
18.     if (ret != 0) {
19.         errno = LittlefsErrno(ret);
20.         ret = VFS_ERROR;
21.     }
23.     return ret;
24. }
26. int LfsMkdir(const char *dirName, mode_t mode)
27. {
28.     int ret;
29.     struct FileOpInfo *fileOpInfo = NULL;
31.     if (dirName == NULL) {
32.         errno = EFAULT;
33.         return VFS_ERROR;
34.     }
36.     if (CheckPathIsMounted(dirName, &fileOpInfo) == FALSE || fileOpInfo == NULL) {
37.         errno = ENOENT;
38.         return VFS_ERROR;
39.     }
41.     ret = lfs_mkdir(&(fileOpInfo->lfsInfo), dirName);
42.     if (ret != 0) {
43.         errno = LittlefsErrno(ret);
44.         ret = VFS_ERROR;
45.     }
47.     return ret;
48. }
49. ......

复制代码

小结

本文介绍了LFS的结构体和全局变量，全局变量的利用接口，分析了下LFS文件利用接口。
如果想更深入的学习 OpenHarmony （鸿蒙南向）全栈开辟的内容，可以参考以放学习文档：
OpenHarmony 开辟环境搭建：https://qr18.cn/CgxrRy

《OpenHarmony源码剖析》：https://qr18.cn/CgxrRy

• 搭建开辟环境
  
• Windows 开辟环境的搭建
  
• Ubuntu 开辟环境搭建
  
• Linux 与 Windows 之间的文件共享
  
• ……
  

系统架构分析：https://qr18.cn/CgxrRy

• 构建子系统
  
• 启动流程
  
• 子系统
  
• 分布式任务调度子系统
  
• 分布式通讯子系统
  
• 驱动子系统
  
• ……
  

OpenHarmony 设备开辟学习手册：https://qr18.cn/CgxrRy

OpenHarmony面试题（内含参考答案）：https://qr18.cn/CgxrRy

写在末了

• 如果你觉得这篇内容对你还蛮有帮助，我想约请你帮我三个小忙：
  
• 点赞，转发，有你们的 『点赞和评论』，才是我创造的动力。
  
• 关注小编，同时可以期待后续文章ing