300来行代码带你实现一个能跑的最小Linux文件系统

Linux作为一个类UNIX系统，其文件系统保留了原始UNIX文件系统的表象形式，它看起来是这个样子：

1. root@name-VirtualBox:/# ls

2. bin boot cdrom dev etc home lib lib64 lost+found media mnt opt proc root run sbin snap srv sys tmp usr var

3. root@name-VirtualBox:/#

4. root@name-VirtualBox:/# ls /home/

5. zy

6. root@name-VirtualBox:/#

7. root@name-VirtualBox:/# ls /usr/

8. bin games include lib lib64 local sbin share src

9. root@name-VirtualBox:/# ls /mnt/

10. project src

它其实是一棵目录树(没有画全)：

然而，虽然所有的UNIX系统以及类UNIX系统的文件系统看起来一样，但是它们的实现却是不尽相同。

作为普通用户，了解文件系统的基本操作就够了；作为应用开发人员，了解文件系统的POSIX接口足矣，但是作为一个对操作系统有着浓厚兴趣的爱好者而言，自己可能就是一个新的文件系统的潜在实现者，所以必须一窥究竟，看看如此外观的文件系统到底是如何实现的。

网上已经有了很多关于UNIX/Linux文件系统实现的资源，但是无一例外，都太复杂了，除了整体的源码分析外，几乎就是针对某个特定文件系统的详解了，如此复杂的这些对于初涉该领域的满腔热情者无疑是一盆冷水，很多人因此望而却步。

• ...

• mount机制是如何实现的？

• inode是如何分配的？磁盘inode和内存inode有什么区别？

• dentry缓存是怎么回事？是如何管理的？

• pagecache是什么？radix树如何管理文件数据缓存？

• cache和buffer的区别又是什么？

• ...

几乎所有的关于Linux文件系统实现的资源都在用不同的语言解释上面的这些问题，这很容易陷入细节的泥潭。

本文以Linux内核为例，用一种稍微不同的方式去描述文件系统的实现。嗯，我会分3个部分来介绍Linux内核的文件系统：

1. Linux文件系统在不同视角下的样子

2. 实现一个很小但能跑的文件系统

3. 接下来要做什么

本文中，我会通过一个实实在在的文件系统实现的例子，试图阐述 实现一个文件系统，哪些是必须的，哪些不是必须的。 这是一个任务驱动的过程，从简单的例子开始。

读过本文之后，相信会对Linux文件系统的实现有一个总体上的宏观把握，然后再去反复推敲上述的细节问题，重读网上的那些经典资源，相信会事半功倍。

Linux文件系统在不同视角下的样子

当然，在给出最简单的tinyfs实现之前，还是会有一个总体的介绍。

如果我们把本文最初描述的那个在几乎所有UNIX/类UNIX系统中长的一模一样的文件系统表面刨开，在Linux内核中，文初的那棵树其实它长下面的样子(其实在大多数类UNIX系统中，它们长得都差不多)：【这张图基于我2010年的一张手绘图修改而成，怀旧的可以参见以下链接：https://blog.csdn.net/dog250/article/details/5822440】

我们看到，Linux系统的文件目录树就是靠上图中的这一系列的链表穿针引线给串在一起的，就像缝制一件衣服一样，最终的成衣就是我们看到的Linux系统目录树，而缝制这件成衣的线以及指导走线的规则便是VFS本身了。

现在只要记住两个重要链表：

1. 文件系统链表。

2. 每一个文件系统的mount挂载点链表。

然后读完本文之后再去结合代码深入分析它们是如何串起整个文件系统的。

VFS之所有可以将机制大相径庭的完全不同的文件系统对外统一成一个样子，完全就是依靠了它的统一的对POSIX文件调用的接口，该接口的结构看上去是下面的样子：

注意上图最下面的那个椭圆，如果要实现一个文件系统，这个椭圆里的东西是关键，它完成了穿针引线的大部分工作。

现在让我们纵向地看一下一个完整的文件系统实现都包括什么，我指的是从POSIX系统调用开始，一直到数据落盘。Linux内核关于文件系统IO，完整的视图如下所示：注意VFS提供的三类接口：

• 和POSIX系统调用的接口 即实现open/read/write的操作的接口。

• 和底层介质的接口 即下接块设备层的接口。

• 如何管理自身 即何时以及如何操作VFS数据结构inode，dentry，mount等对象。

一个文件系统如果能实现上面三类接口，那它就是个完整的文件系统了。

我们恰好可以从设计并实现一个最基本的这样的文件系统开始。一个基本的文件系统，其着重点在于上图中红色的部分，而其它部分则不是必不可少的，但是却是让该文件系统变得优秀(而不仅仅是可用)所必须的。

实现一个很小但能跑的文件系统

为什么要实现这么一个文件系统，难道没人已经做了这个工作吗？做这个工作的意义何在？

原因如下：

• 我没有找到现成的比较完整且炫酷的作品。 当然有人写这种文件系统练手，但是看下来要么就是使用了libfs.c里封装好的接口，要么就是没有自己设计文件系统的底层存储格式。

• 下班的班车在路上堵了一个多小时，无聊撸会儿代码。

然而确实，我没有找到简单的 最小文件系统 实现，也许你会说Linux内核自带的ramfs难道不就是一个现成的吗？的确算一个，但它有两个问题导致你无法领略实现一个文件系统的全过程，注意，我说的可是全过程：

1. ramfs无法让你自己设计底层模拟介质的格式，不完整。

2. ramfs调用了大量的fs/libfs.c中的内核库例程，不纯碎。

为了 追求完整， 如果你把如何组织一块内核作为ramfs的底层介质这部分代码全部看完，如果你把libfs.c里的库实现全部看完，我想ramfs也就不算一个 足够简单 的文件系统实例了。

看到了么？要想代码简单，你就不得不使用libfs.c里的现成的例程，这将损失你实现一个文件系统的完整性体验，反之，要想完整实现一个文件系统，你可能不得不自己写大量的代码，这却并不简单。

如何既完备，又足够简单呢？

对于我这种编程水平渣渣的内核爱好者而言，如何在堵车的一个多小时内完成一个可以编译通过的文件系统(我承认完全能跑是我回到家后又调试了一个多小时才完成的...)，这对于我而言，是一个挑战，但我要试一试，没想到就成功了。所以才有了今天的分享。

我从最底层的介质结构的设计开始。

我并没有真实的硬件介质，也并不打算编写专门的 格式化程序 去格式化一块内存区域，所以我直接用大数组定义一块内存，它便是我的模拟介质了，我的tinyfs的文件格式如下：

1. // tinyfs.h

2. #define MAXLEN 8

3. #define MAX_FILES 32

4. #define MAX_BLOCKSIZE 512

5. // 定义每一个目录项的格式

6. struct dir_entry {

7. char filename[MAXLEN];

8. uint8_t idx;

9. };

10. // 定义每一个文件的格式。

11. struct file_blk {

12. uint8_t busy;

13. mode_t mode;

14. uint8_t idx;

15. union {

16. uint8_t file_size;

17. uint8_t dir_children;

18. };

19. char data[0];

20. };

21. // OK，下面的block数组所占据的连续内存就是我的tinyfs的介质，每一个元素代表一个文件。

22. // struct file_blk block[MAX_FILES+1];

这个文件系统的格式非常的Low：

1. 最多容纳512个文件(包括目录在内)。

2. 每个文件包括元数据在内最多32个字节。

3. 文件名最多8个字节。

之所以这么Low是因为它只是一个开始， 当这个文件系统实现并且能跑之后，你会发现它因为Low而带来的不足和一些代价，而弥补这些不足正好是优化的动机，带着你逐步实现一个更加不Low的文件系统，在实现的过程中，你会窥见并掌握Linux内核文件系统的全貌和细节。 完美的学习过程，OK！

下面是代码：

1. // tinyfs.c

2. #include <linux/init.h>

3. #include <linux/module.h>

4. #include <linux/fs.h>

5. #include <linux/uaccess.h>

6. #include "tinyfs.h"

7. struct file_blk block[MAX_FILES+1];

8. int curr_count = 0; // 我勒个去，竟然使用了全局变量！

9. // 获得一个尚未使用的文件块，保存新创建的文件或者目录

10. static int get_block(void)

11. {

12. int i;

13. // 就是一个遍历，但实现快速。

14. for (i = 2; i < MAX_FILES; i++) {

15. if (!block[i].busy) {

16. block[i].busy = 1;

17. return i;

18. }

19. }

20. return -1;

21. }

22. static struct inode_operations tinyfs_inode_ops;

23. // 读取目录的实现

24. static int tinyfs_readdir(struct file *filp, void *dirent, filldir_t filldir)

25. {

26. loff_t pos;

27. struct file_blk *blk;

28. struct dir_entry *entry;

29. int i;

30. pos = filp->f_pos;

31. if (pos)

32. return 0;

33. blk = (struct file_blk *)filp->f_dentry->d_inode->i_private;

34. if (!S_ISDIR(blk->mode)) {

35. return -ENOTDIR;

36. }

37. // 循环获取一个目录的所有文件的文件名

38. entry = (struct dir_entry *)&blk->data[0];

39. for (i = 0; i < blk->dir_children; i++) {

40. filldir(dirent, entry[i].filename, MAXLEN, pos, entry[i].idx, DT_UNKNOWN);

41. filp->f_pos += sizeof(struct dir_entry);

42. pos += sizeof(struct dir_entry);

43. }

44. return 0;

45. }

46. // read实现

47. ssize_t tinyfs_read(struct file * filp, char __user * buf, size_t len, loff_t *ppos)

48. {

49. struct file_blk *blk;

50. char *buffer;

51. blk = (struct file_blk *)filp->f_path.dentry->d_inode->i_private;

52. if (*ppos >= blk->file_size)

53. return 0;

54. buffer = (char *)&blk->data[0];

55. len = min((size_t) blk->file_size, len);

56. if (copy_to_user(buf, buffer, len)) {

57. return -EFAULT;

58. }

59. *ppos += len;

60. return len;

61. }

62. // write实现

63. ssize_t tinyfs_write(struct file * filp, const char __user * buf, size_t len, loff_t * ppos)

64. {

65. struct file_blk *blk;

66. char *buffer;

67. blk = filp->f_path.dentry->d_inode->i_private;

68. buffer = (char *)&blk->data[0];

69. buffer += *ppos;

70. if (copy_from_user(buffer, buf, len)) {

71. return -EFAULT;

72. }

73. *ppos += len;

74. blk->file_size = *ppos;

75. return len;

76. }

77. const struct file_operations tinyfs_file_operations = {

78. .read = tinyfs_read,

79. .write = tinyfs_write,

80. };

81. const struct file_operations tinyfs_dir_operations = {

82. .owner = THIS_MODULE,

83. .readdir = tinyfs_readdir,

84. };

85. // 创建文件的实现

86. static int tinyfs_do_create(struct inode *dir, struct dentry *dentry, umode_t mode)

87. {

88. struct inode *inode;

89. struct super_block *sb;

90. struct dir_entry *entry;

91. struct file_blk *blk, *pblk;

92. int idx;

93. sb = dir->i_sb;

94. if (curr_count >= MAX_FILES) {

95. return -ENOSPC;

96. }

97. if (!S_ISDIR(mode) && !S_ISREG(mode)) {

98. return -EINVAL;

99. }

100. inode = new_inode(sb);

101. if (!inode) {

102. return -ENOMEM;

103. }

104. inode->i_sb = sb;

105. inode->i_op = &tinyfs_inode_ops;

106. inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;

107. idx = get_block(); // 获取一个空闲的文件块保存新文件

108. blk = &block[idx];

109. inode->i_ino = idx;

110. blk->mode = mode;

111. curr_count ++;

112. if (S_ISDIR(mode)) {

113. blk->dir_children = 0;

114. inode->i_fop = &tinyfs_dir_operations;

115. } else if (S_ISREG(mode)) {

116. blk->file_size = 0;

117. inode->i_fop = &tinyfs_file_operations;

118. }

119. inode->i_private = blk;

120. pblk = (struct file_blk *)dir->i_private;

121. entry = (struct dir_entry *)&pblk->data[0];

122. entry += pblk->dir_children;

123. pblk->dir_children ++;

124. entry->idx = idx;

125. strcpy(entry->filename, dentry->d_name.name);

126. // VFS穿针引线的关键步骤，将VFS的inode链接到链表

127. inode_init_owner(inode, dir, mode);

128. d_add(dentry, inode);

129. return 0;

130. }

131. static int tinyfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)

132. {

133. return tinyfs_do_create(dir, dentry, S_IFDIR | mode);

134. }

135. static int tinyfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool excl)

136. {

137. return tinyfs_do_create(dir, dentry, mode);

138. }

139. static struct inode *tinyfs_iget(struct super_block *sb, int idx)

140. {

141. struct inode *inode;

142. struct file_blk *blk;

143. inode = new_inode(sb);

144. inode->i_ino = idx;

145. inode->i_sb = sb;

146. inode->i_op = &tinyfs_inode_ops;

147. blk = &block[idx];

148. if (S_ISDIR(blk->mode))

149. inode->i_fop = &tinyfs_dir_operations;

150. else if (S_ISREG(blk->mode))

151. inode->i_fop = &tinyfs_file_operations;

152. inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;

153. inode->i_private = blk;

154. return inode;

155. }

156. struct dentry *tinyfs_lookup(struct inode *parent_inode, struct dentry *child_dentry, unsigned int flags)

157. {

158. struct super_block *sb = parent_inode->i_sb;

159. struct file_blk *blk;

160. struct dir_entry *entry;

161. int i;

162. blk = (struct file_blk *)parent_inode->i_private;

163. entry = (struct dir_entry *)&blk->data[0];

164. for (i = 0; i < blk->dir_children; i++) {

165. if (!strcmp(entry[i].filename, child_dentry->d_name.name)) {

166. struct inode *inode = tinyfs_iget(sb, entry[i].idx);

167. struct file_blk *inner = (struct file_blk *)inode->i_private;

168. inode_init_owner(inode, parent_inode, inner->mode);

169. d_add(child_dentry, inode);

170. return NULL;

171. }

172. }

173. return NULL;

174. }

175. int tinyfs_rmdir(struct inode *dir, struct dentry *dentry)

176. {

177. struct inode *inode = dentry->d_inode;

178. struct file_blk *blk = (struct file_blk *)inode->i_private;

179. blk->busy = 0;

180. return simple_rmdir(dir, dentry);

181. }

182. int tinyfs_unlink(struct inode *dir, struct dentry *dentry)

183. {

184. int i;

185. struct inode *inode = dentry->d_inode;

186. struct file_blk *blk = (struct file_blk *)inode->i_private;

187. struct file_blk *pblk = (struct file_blk *)dir->i_private;

188. struct dir_entry *entry;

189. // 更新其上层目录

190. entry = (struct dir_entry *)&pblk->data[0];

191. for (i = 0; i < pblk->dir_children; i++) {

192. if (!strcmp(entry[i].filename, dentry->d_name.name)) {

193. int j;

194. for (j = i; j < pblk->dir_children - 1; j++) {

195. memcpy(&entry[j], &entry[j+1], sizeof(struct dir_entry));

196. }

197. pblk->dir_children --;

198. break;

199. }

200. }

201. blk->busy = 0;

202. return simple_unlink(dir, dentry);

203. }

204. static struct inode_operations tinyfs_inode_ops = {

205. .create = tinyfs_create,

206. .lookup = tinyfs_lookup,

207. .mkdir = tinyfs_mkdir,

208. .rmdir = tinyfs_rmdir,

209. .unlink = tinyfs_unlink,

210. };

211. int tinyfs_fill_super(struct super_block *sb, void *data, int silent)

212. {

213. struct inode *root_inode;

214. int mode = S_IFDIR;

215. root_inode = new_inode(sb);

216. root_inode->i_ino = 1;

217. inode_init_owner(root_inode, NULL, mode);

218. root_inode->i_sb = sb;

219. root_inode->i_op = &tinyfs_inode_ops;

220. root_inode->i_fop = &tinyfs_dir_operations;

221. root_inode->i_atime = root_inode->i_mtime = root_inode->i_ctime = CURRENT_TIME;

222. block[1].mode = mode;

223. block[1].dir_children = 0;

224. block[1].idx = 1;

225. block[1].busy = 1;

226. root_inode->i_private = &block[1];

227. sb->s_root = d_make_root(root_inode);

228. curr_count ++;

229. return 0;

230. }

231. static struct dentry *tinyfs_mount(struct file_system_type *fs_type, int flags, const char *dev_name, void *data)

232. {

233. return mount_nodev(fs_type, flags, data, tinyfs_fill_super);

234. }

235. static void tinyfs_kill_superblock(struct super_block *sb)

236. {

237. kill_anon_super(sb);

238. }

239. struct file_system_type tinyfs_fs_type = {

240. .owner = THIS_MODULE,

241. .name = "tinyfs",

242. .mount = tinyfs_mount,

243. .kill_sb = tinyfs_kill_superblock,

244. };

245. static int tinyfs_init(void)

246. {

247. int ret;

248. memset(block, 0, sizeof(block));

249. ret = register_filesystem(&tinyfs_fs_type);

250. if (ret)

251. printk("register tinyfs failed\n");

252. return ret;

253. }

254. static void tinyfs_exit(void)

255. {

256. unregister_filesystem(&tinyfs_fs_type);

257. }

258. module_init(tinyfs_init);

259. module_exit(tinyfs_exit);

260. MODULE_LICENSE("GPL");

review代码后，你可能已经发现了几个问题：

1. 这个tinyfs文件系统存储格式中怎么没有超级块？(竟然使用了全局变量)

2. 这个tinyfs文件系统存储格式中怎么没有inode表或者空闲位图？

3. 这个tinyfs文件系统怎么将元数据和文件数据放在了一起？

4. 这个文件系统怎么不支持并发？没见到一把锁啊！

5. ...

嗯，其实这些问题目前而言还都不是问题，它们并不阻碍这个文件系统的真实性，它用起来是那么的真实。

没有任何规范规定一个文件系统存储格式必须有什么或者必须没有什么，文件系统格式只是一个 看上去还可以的信息持久化记录格式 ，只要下次能根据某些信息将文件读取出来，任何格式都是OK的。

之所以很多人会认为一个文件系统的格式必须要符合某种规范，完全是因为人们看的最多的那些文件系统ext3，ext4，ntfs等恰好是那样做的罢了。不过事实证明，那样做确实是很好的。在可用的玩具完成之后，就要考虑 性能，健壮性，可扩展性 等这些工程因素了。而ext3/4，ntfs，xfs则充分考虑了这些。

逐渐的，权威变成了规范，至少成了一种范式或者模式，这是计算机领域常有的事，见怪不怪。

我们来使用下这个文件系统：

1. [root@localhost ~]# insmod ./tinyfs.ko

2. [root@localhost ~]# mount -t tinyfs none /mnt

OK，挂载成功。

这里又有疑问了，为什么是none挂载，而不是一个块设备，比如/dev/sda1之类的。

这是因为我根本没有将介质(其实是一块连续的内存)抽象成块设备，如果引入块设备抽象，势必要导出device层操作接口，这样做并不困难，但却太麻烦，且块设备抽象和文件系统的实现核心无关。本文不是讲块设备的，加之班车上的堵车时间有限，故不做抽象。

好了，现在让我们来折腾下/mnt目录，该目录就是我的tinyfs的挂载目录了，在其下读写文件，就是在tinyfs的内存介质上读写文件：

1. [root@localhost ~]# cd /mnt/

2. [root@localhost mnt]# ls

3. [root@localhost mnt]#

4. [root@localhost mnt]# echo 11111 >./a

5. [root@localhost mnt]# cat ./a

6. 11111

7. [root@localhost mnt]# mkdir dir1

8. [root@localhost mnt]# echo 22222 >./dir1/b

9. [root@localhost mnt]#

10. [root@localhost mnt]# cat ./dir1/b

11. 22222

12. [root@localhost mnt]#

13. [root@localhost mnt]# tree

14. .

15. ├── a

16. └── dir1

17. └── b

18. 1 directory, 2 files

19. [root@localhost mnt]# echo 333 >./dir1/c

20. [root@localhost mnt]# cat ./dir1/c

21. 333

22. [root@localhost mnt]# tree

23. .

24. ├── a

25. └── dir1

26. ├── b

27. └── c

28. 1 directory, 3 files

29. [root@localhost mnt]# rm -f ./dir1/c

30. [root@localhost mnt]#

31. [root@localhost mnt]# tree

32. .

33. ├── a

34. └── dir1

35. └── b

36. 1 directory, 2 files

37. [root@localhost mnt]# rm -rf dir1

38. rm: 无法删除"dir1": 不允许的操作

39. [root@localhost mnt]#

除了最后一个删除目录的操作，其它的都OK，这也是预期之中，毕竟删除目录是TODO嘛。

接下来要做什么

一共300来行的代码(省去了很多异常判断和处理，真实情况下，这些要占据80%的代码量)，非常容易读懂，你会发现这个文件系统实现是如此之low，然而却能看起来像真的一样。

这意味着完成和完美真的是两回事！

很多最终看起来很大型的东西，都是都这种刚刚完成可以用开始的。

很明显，这个代码没有使用块层来和底层介质通信，而是直接操作了底层介质，也就是那块连续的内存。因为我用内存模拟介质，尚且OK，如果底层真的有一个类似磁盘那样的慢速介质，每次操作直接读写block将是不可接受的。但如果你想获得性能上的提升，就必须使用块层的缓存机制，以及pagecache机制。

所以，方向很明确，我们有了一个todolist：

• fix掉可能的bug，主要是引用计数的管理方面。

• 设计更好的文件系统底层存储格式，至少让它看起来更像回事。 比如引入超级块保存全局元数据，引入空闲索引位图，引入优雅的空闲块管理算法，类似内存管理那样，减少内外的存储碎片，引入一些启发式策略，比如预读，合并写，当然，这些属于调度的范畴，但无论如何， 良好的存储结构可以极大影响启发式策略的实施。

• 使用块层标准接口进行IO，比如 *sb_bread，mark_buffer_dirty 这样的接口。*

• 使用pagecache进行数据cache。

这些todo完成，意味着对Linux内核文件系统实现原理的彻底掌握，从一个简单的刚刚可用的tinyfs开始(这花不了多少时间)，到整理出一份todolist，到完成这些todo，这便是一个任务驱动的学习过程。

---

回过头来看Linux文件系统IO的纵向视图：这次注意蓝色部分，我们的TODO就是要补充这部分的实现。

好了，换一个视角看VFS。

我们把Linux内核内存中的VFS看作是磁盘等慢速介质中特定文件系统的缓存，这是一个典型的 分级存储结构， 就好像CPU cache和内存的关系一样。

在这个视角下，如何完成上图蓝色框框中的部分，可参考的现成范式就太多了。但无论如何都要解决的是：

• 哪些磁盘数据有资格进入到内存VFS的cache结构？

• 这些被cache的磁盘文件系统数据cache在什么地方？

• cache的淘汰算法是怎样的？

Linux内核已经给了我们一个现成的答案：

• 磁盘IO依然遵循局部性原则，无论是时间局部性还是空间局部性，磁盘IO的局部性原则和磁盘结构(磁道，扇区等)以及启发式预读算法结合在一起，共同决定哪些数据要cache在内存。

• 磁盘数据以pagecache的形式保存在内存，当然你也可以DirectIO。

• cache淘汰根据LRU以及系统内存的吃紧程度来进行实施。具体过程涉及脏页如何回写。

当然，如果你觉得这些不够好，你也可以设计你自己的。总之，这是一块非常独立的工作，正如我图中所示，这部分工作的目标是，在文件系统刚好可以工作后， 让事情变得更加完美有趣！

   浙江温州皮鞋湿，下雨进水不会胖。

（完）

查看我们精华技术文章请移步:

更多精彩，尽在"Linux阅码场"，扫描下方二维码关注

感谢您的耐心阅读，请随手转发一下或者点个“在看”吧~