鸿蒙轻内核源码分析：虚拟文件系统 VFS

转x33g5p2x  于2022-02-07 转载在 其他  
字(7.7k)|赞(0)|评价(0)|浏览(471)

本文分享自华为云社区《鸿蒙轻内核M核源码分析系列二一 01 虚拟文件系统VFS》，作者：zhushy 。

VFS（Virtual File System）是文件系统的虚拟层，它不是一个实际的文件系统，而是一个异构文件系统之上的软件粘合层，为用户提供统一的类 Unix 文件操作接口。由于不同类型的文件系统接口不统一，若系统中有多个文件系统类型，访问不同的文件系统就需要使用不同的非标准接口。而通过在系统中添加 VFS 层，提供统一的抽象接口，屏蔽了底层异构类型的文件系统的差异，使得访问文件系统的系统调用不用关心底层的存储介质和文件系统类型，提高开发效率。本文先介绍下 VFS 的结构体和全局变量，然后详细分析下 VFS 文件操作接口。文中所涉及的源码，均可以在开源站点kernel_liteos_m: LiteOS kernel for devices with few resources, such as the MCU | 适用于MCU等各种资源极小设备的LiteOS内核 获取。

1、VFS 结构体定义

在文件 components\fs\vfs\fs_operations.h 中定义了 VFS 虚拟文件系统操作涉及的结构体。⑴处的 struct MountOps 结构体封装了挂载相关的操作，包含挂载、卸载和文件系统统计操作。⑵处的 struct FsMap 结构体映射文件系统类型及其对应的挂载操作和文件系统操作，支持的文件类型包含“fat”和“littlefs”两种，通过这个结构体可以获取对应文件类型的挂载操作及文件系统操作接口。⑶处的 struct FileOps 封装文件系统的操作接口，包含文件操作、目录操作，统计等相应的接口。

  1. ⑴  struct MountOps {
  2.         int (*Mount)(const char *source, const char *target, const char *filesystemtype, unsigned long mountflags,
  3.             const void *data);
  4.         int (*Umount)(const char* target);
  5.         int (*Umount2)(const char* target, int flag);
  6.         int (*Statfs)(const char *path, struct statfs *buf);
  7.     };
  9. ⑵  struct FsMap {
  10.         const char *fileSystemtype;
  11.         const struct MountOps *fsMops;
  12.         const struct FileOps *fsFops;
  13.     };
  15. ⑶  struct FileOps {
  16.         int (*Open)(const char *path, int openFlag, ...);
  17.         int (*Close)(int fd);
  18.         int (*Unlink)(const char *fileName);
  19.         int (*Rmdir)(const char *dirName);
  20.         int (*Mkdir)(const char *dirName, mode_t mode);
  21.         struct dirent *(*Readdir)(DIR *dir);
  22.         DIR *(*Opendir)(const char *dirName);
  23.         int (*Closedir)(DIR *dir);
  24.         int (*Read)(int fd, void *buf, size_t len);
  25.         int (*Write)(int fd, const void *buf, size_t len);
  26.         off_t (*Seek)(int fd, off_t offset, int whence);
  27.         int (*Getattr)(const char *path, struct stat *buf);
  28.         int (*Rename)(const char *oldName, const char *newName);
  29.         int (*Fsync)(int fd);
  30.         int (*Fstat)(int fd, struct stat *buf);
  31.         int (*Stat)(const char *path, struct stat *buf);
  32.         int (*Ftruncate)(int fd, off_t length);
  33.     };

2、VFS 重要的内部全局变量

在文件 components\fs\vfs\los_fs.c 中有 2 个全局变量比较重要，⑴处定义的数组 g_fsmap 维护文件系统类型映射信息，数组大小为 2，支持"fat"和"littlefs"文件类型。⑵处的变量 g_fs 根据挂载的文件类型指向数组 g_fsmap 中的 FsMap 类型元素。⑶处的函数 InitMountInfo()会给数组 g_fsmap 进行初始化赋值。第 0 个元素维护的"fat"文件类型的文件系统映射信息，第 1 个元素维护的"littlefs"文件类型的文件系统映射信息。涉及到的挂载操作、文件系统操作变量 g_fatfsMnt、g_fatfsFops、g_lfsMnt、g_lfsFops 在对应的文件系统文件中定义。⑷处的函数 MountFindfs()用于根据文件类型从数组中获取文件映射信息。

  1. ⑴  static struct FsMap g_fsmap[MAX_FILESYSTEM_LEN] = {0};
  2. ⑵  static struct FsMap *g_fs = NULL;
  4. ⑶  static void InitMountInfo(void)
  5.     {
  6.     #if (LOSCFG_SUPPORT_FATFS == 1)
  7.         extern struct MountOps g_fatfsMnt;
  8.         extern struct FileOps g_fatfsFops;
  9.         g_fsmap[0].fileSystemtype = strdup("fat");
  10.         g_fsmap[0].fsMops = &g_fatfsMnt;
  11.         g_fsmap[0].fsFops = &g_fatfsFops;
  12.     #endif
  13.     #if (LOSCFG_SUPPORT_LITTLEFS == 1)
  14.         extern struct MountOps g_lfsMnt;
  15.         extern struct FileOps g_lfsFops;
  16.         g_fsmap[1].fileSystemtype = strdup("littlefs");
  17.         g_fsmap[1].fsMops = &g_lfsMnt;
  18.         g_fsmap[1].fsFops = &g_lfsFops;
  19.     #endif
  20.     }
  22. ⑷  static struct FsMap *MountFindfs(const char *fileSystemtype)
  23.     {
  24.         struct FsMap *m = NULL;
  26.         for (int i = 0; i < MAX_FILESYSTEM_LEN; i++) {
  27.             m = &(g_fsmap[i]);
  28.             if (m->fileSystemtype && strcmp(fileSystemtype, m->fileSystemtype) == 0) {
  29.                 return m;
  30.             }
  31.         }
  33.         return NULL;
  34.     }

3、VFS 相关的操作接口

在之前的系列文章《鸿蒙轻内核 M 核源码分析系列十九 Musl LibC》中介绍了相关的接口，那些接口会调用 VFS 文件系统中操作接口。对每个接口的用途用法不再描述，快速记录下各个操作接口。

3.1 挂载卸载操作​

挂载卸载操作包含 LOS_FsMount、LOS_FsUmount、LOS_FsUmount2 等 3 个操作。⑴处在挂载文件系统之前，需要初始化文件系统映射信息，只会操作一次。⑵处根据文件系统类型获取对应的文件类型映射信息。从这里，可以获知，LiteOS-M 内核只能同时支持一个文件系统，不能只支持 fat 又支持 littlefs。⑶处对应对应的文件系统挂载接口实现挂载操作。其他两个函数同样比较简单，自行阅读代码即可。

  1. int LOS_FsMount(const char *source, const char *target,
  2.                     const char *filesystemtype, unsigned long mountflags,
  3.                     const void *data)
  4.     {
  5.         static int initFlag = 0;
  7. ⑴      if (initFlag == 0) {
  8.             InitMountInfo();
  9.             initFlag = 1;
  10.         }
  12. ⑵      g_fs = MountFindfs(filesystemtype);
  13.         if (g_fs == NULL) {
  14.             errno = ENODEV;
  15.             return FS_FAILURE;
  16.         }
  18.         if (g_fs->fsMops == NULL || g_fs->fsMops->Mount == NULL) {
  19.             errno = ENOSYS;
  20.             return FS_FAILURE;
  21.         }
  23. ⑶      return g_fs->fsMops->Mount(source, target, filesystemtype, mountflags, data);
  24.     }
  26.     int LOS_FsUmount(const char *target)
  27.     {
  28.         if (g_fs == NULL) {
  29.             errno = ENODEV;
  30.             return FS_FAILURE;
  31.         }
  32.         if (g_fs->fsMops == NULL || g_fs->fsMops->Umount == NULL) {
  33.             errno = ENOSYS;
  34.             return FS_FAILURE;
  35.         }
  36.         return g_fs->fsMops->Umount(target);
  37.     }
  39.     int LOS_FsUmount2(const char *target, int flag)
  40.     {
  41.         if (g_fs == NULL) {
  42.             errno = ENODEV;
  43.             return FS_FAILURE;
  44.         }
  45.         if (g_fs->fsMops == NULL || g_fs->fsMops->Umount2 == NULL) {
  46.             errno = ENOSYS;
  47.             return FS_FAILURE;
  48.         }
  49.         return g_fs->fsMops->Umount2(target, flag);
  50.     }

3.2 文件目录操作​

VFS 封装的文件目录操作接口包含 LOS_Open、LOS_Close、LOS_Read、LOS_Write、LOS_Opendir、LOS_Readdir、LOS_Closedir 等等。对具体的文件类型的文件目录操作接口进行封装，代码比较简单，自行阅读即可，部分代码片段如下。
 

  1. ......
  3. int LOS_Unlink(const char *path)
  4. {
  5.     if (g_fs == NULL) {
  6.         errno = ENODEV;
  7.         return FS_FAILURE;
  8.     }
  9.     if (g_fs->fsFops == NULL || g_fs->fsFops->Unlink == NULL) {
  10.         errno = ENOSYS;
  11.         return FS_FAILURE;
  12.     }
  13.     return g_fs->fsFops->Unlink(path);
  14. }
  16. int LOS_Fstat(int fd, struct stat *buf)
  17. {
  18.     if (g_fs == NULL) {
  19.         errno = ENODEV;
  20.         return FS_FAILURE;
  21.     }
  22.     if (g_fs->fsFops == NULL || g_fs->fsFops->Fstat == NULL) {
  23.         errno = ENOSYS;
  24.         return FS_FAILURE;
  25.     }
  26.     return g_fs->fsFops->Fstat(fd, buf);
  27. }
  29. ......
  31. int LOS_Mkdir(const char *path, mode_t mode)
  32. {
  33.     if (g_fs == NULL) {
  34.         errno = ENODEV;
  35.         return FS_FAILURE;
  36.     }
  37.     if (g_fs->fsFops == NULL || g_fs->fsFops->Mkdir == NULL) {
  38.         errno = ENOSYS;
  39.         return FS_FAILURE;
  40.     }
  41.     return g_fs->fsFops->Mkdir(path, mode);
  42. }
  44. DIR *LOS_Opendir(const char *dirName)
  45. {
  46.     if (g_fs == NULL) {
  47.         errno = ENODEV;
  48.         return NULL;
  49.     }
  50.     if (g_fs->fsFops == NULL || g_fs->fsFops->Opendir == NULL) {
  51.         errno = ENOSYS;
  52.         return NULL;
  53.     }
  54.     return g_fs->fsFops->Opendir(dirName);
  55. }
  56. ......

3.3 随机数文件​

文件/dev/random 可以用于产生随机数。在开启宏 LOSCFG_RANDOM_DEV 时，LiteOS-M 支持随机数文件。从⑴处可知随机数依赖文件~/openharmony/base/security/huks/interfaces/innerkits/huks_lite/hks_client.h 和 hks_tmp_client.c，这些文件用来产生随机数。⑵处定义的 RANDOM_DEV_FD 和 RANDOM_DEV_PATH 分别是随机数文件的文件描述符和随机数文件路径。

  1. #ifdef LOSCFG_RANDOM_DEV
  3.     ⑴  #include "hks_client.h"
  5.     ⑵  #define RANDOM_DEV_FD  CONFIG_NFILE_DESCRIPTORS + CONFIG_NSOCKET_DESCRIPTORS
  7.     #define RANDOM_DEV_PATH  "/dev/random"
  9.     #endif

3.3.1 随机 LOS_Open 和 LOS_Close

该函数打开一个文件，获取文件描述符用于进一步操作。⑴处表示对于随机数文件，打开的标签选项只能支持指定的这些，否则会返回错误码。⑵处获取标准路径，如果获取失败，返回错误码。⑶处比较获取的标准路径是否为 RANDOM_DEV_PATH，在确认是随机数路径时，⑷处开始判断。如果访问模式为只读，返回错误，如果打开选项标签是目录，返回错误。如果不是上述错误情形，返回随机数文件描述符。⑸处如果获取的标准路径为“/”或“/dev”，则根据不同的选项，返回不同的错误码。

  1. int LOS_Open(const char *path, int oflag, ...)
  2. {
  3. #ifdef LOSCFG_RANDOM_DEV
  4.     unsigned flags = O_RDONLY | O_WRONLY | O_RDWR | O_APPEND | O_CREAT | O_LARGEFILE | O_TRUNC | O_EXCL | O_DIRECTORY;
  5. ⑴  if ((unsigned)oflag & ~flags) {
  6.         errno = EINVAL;
  7.         return FS_FAILURE;
  8.     }
  10.     size_t pathLen = strlen(path) + 1;
  11.     char *canonicalPath = (char *)malloc(pathLen);
  12.     if (!canonicalPath) {
  13.         errno = ENOMEM;
  14.         return FS_FAILURE;
  15.     }
  16. ⑵  if (GetCanonicalPath(NULL, path, canonicalPath, pathLen) == 0) {
  17.         FREE_AND_SET_NULL(canonicalPath);
  18.         errno = ENOMEM;
  19.         return FS_FAILURE;
  20.     }
  22. ⑶  if (strcmp(canonicalPath, RANDOM_DEV_PATH) == 0) {
  23.         FREE_AND_SET_NULL(canonicalPath);
  24. ⑷      if ((O_ACCMODE & (unsigned)oflag) != O_RDONLY) {
  25.             errno = EPERM;
  26.             return FS_FAILURE;
  27.         }
  28.         if ((unsigned)oflag & O_DIRECTORY) {
  29.             errno = ENOTDIR;
  30.             return FS_FAILURE;
  31.         }
  32.         return RANDOM_DEV_FD;
  33.     }
  34. ⑸  if (strcmp(canonicalPath, "/") == 0 || strcmp(canonicalPath, "/dev") == 0) {
  35.         FREE_AND_SET_NULL(canonicalPath);
  36.         if ((unsigned)oflag & O_DIRECTORY) {
  37.             errno = EPERM;
  38.             return FS_FAILURE;
  39.         }
  40.         errno = EISDIR;
  41.         return FS_FAILURE;
  42.     }
  43.     FREE_AND_SET_NULL(canonicalPath);
  44. #endif
  45. ......
  46. }

对于随机数文件，关闭时，直接返回成功，不需要额外操作。代码片段如下：

  1. int LOS_Close(int fd)
  3.     {
  5.     #ifdef LOSCFG_RANDOM_DEV
  7.     if (fd == RANDOM_DEV_FD) {
  9.     return FS_SUCCESS;
  11.     }
  13.     #endif
  15.     ......
  17.     }

3.3.2 随机 LOS_Read 和 LOS_Write

随机数文件读写使用 LOS_Read 和 LOS_Write 接口。读取时，⑴处先对传入参数进行校验，如果读取字节数为 0，则返回 0；如果读取的缓存地址为空，返回-1；如果读的字节大于 1024，则使用 1024。⑵处调用 hks_generate_random()产生随机数。由于随机数文件是只读的，如果尝试写入会返回-1 错误码。

  1. ssize_t LOS_Read(int fd, void *buf, size_t nbyte)
  2. {
  3. #ifdef LOSCFG_RANDOM_DEV
  4.     if (fd == RANDOM_DEV_FD) {
  5. ⑴      if (nbyte == 0) {
  6.             return FS_SUCCESS;
  7.         }
  8.         if (buf == NULL) {
  9.             errno = EINVAL;
  10.             return FS_FAILURE;
  11.         }
  12.         if (nbyte > 1024) { /* 1024, max random_size */
  13.             nbyte = 1024; /* hks_generate_random: random_size must <= 1024 */
  14.         }
  15.         struct hks_blob key = {HKS_BLOB_TYPE_RAW, (uint8_t *)buf, nbyte};
  16. ⑵      if (hks_generate_random(&key) != 0) {
  17.             errno = EIO;
  18.             return FS_FAILURE;
  19.         }
  20.         return (ssize_t)nbyte;
  21.     }
  22. #endif
  23. ......
  24. }
  26. ssize_t LOS_Write(int fd, const void *buf, size_t nbyte)
  27. {
  28. #ifdef LOSCFG_RANDOM_DEV
  29.     if (fd == RANDOM_DEV_FD) {
  30.         errno = EBADF; /* "/dev/random" is readonly */
  31.         return FS_FAILURE;
  32.     }
  33. #endif
  34. ......
  35. }

小结

本文介绍了 VFS 的结构体和全局变量，分析了下 VFS 文件操作接口，对于随机数文件也进行了分析。时间仓促和能力关系，如有失误，欢迎指正。感谢阅读，如有任何问题、建议，都可以博客下留言给我，谢谢。

参考资料

  • HarmonyOS Device>文档指南>基础能力-虚拟文件系统

点击关注，第一时间了解华为云新鲜技术~

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://huaweicloud.blog.csdn.net/article/details/122716903

内容来源于网络，如有侵权，请联系作者删除！

文件系统harmonyos技术交流华为鸿蒙轻内核源码虚拟文件系统VFS

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com