1. tmpfs 内存简介
tmpfs 文件系统是 pod 中常见的一种“存储”介质，也叫 ram disk，都是一个东西
tmpfs 的特殊的地方在于：
- 首先它是个文件系统
- 但是它的文件数据是完全存放在内存里面的，不在磁盘上
所以要讲 tmpfs 的话，就得把这两部分都讲清楚，一个是文件系统的实现，一个是底层“持久化”层内存的管理
通常应用程序之间会通过 tmpfs 文件系统来实现高效的数据共享
/dev/shm 就是一个最典型的 tmpfs 文件系统，是操作系统为了解决大多数程序数据共享而默认挂在的一个 tmpfs
2. tmpfs 文件系统的实现
我们知道 file 是linux内核最重要的设计，一切皆文件
除了普通的文件，平时我们接触到的，unix管道、socket、proc、cgroup 等等，都是基于文件的实现
为了实现灵活可扩展的文件系统架构，Linux设计了 virtual file system 抽象层，简称 vfs，对用户台程序屏蔽了所有具体的底层文件系统的实现细节，提供统一的文件系统接口
2.1. virtual file system 接口定义
vfs 属于一个专题，我们这里不讲那么复杂，有时间可以专门展开讲
vfs 定义了文件系统实现最关键的2个接口：
- 一个是 struct file_operations：文件读写的接口
- 一个是 struct inode_operations：inode操作接口
inode_opertions 定义如下：
struct inode_operations {
int (*create) (struct user_namespace *, struct inode *,struct dentry *, umode_t, bool);
int (*symlink) (struct user_namespace *, struct inode *,struct dentry *,const char *);
int (*mkdir) (struct user_namespace *, struct inode *,struct dentry *,umode_t);
int (*rmdir) (struct inode *,struct dentry *);
/* 省略一万字 */
};
是不是很熟悉？
file_operations 的定义如下：
struct file_operations {
int (*open) (struct inode *, struct file *);
loff_t (*llseek) (struct file *, loff_t, int);
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
/* 省略一万字 */
};
是不是也很熟悉？
内核 tmpfs 文件系统的源码：mm/shmem.c
tmpfs 其实并没有实现 vfs 中的所有接口，主要原因是因为由于绝大部分的 file system 底层实现其实都是一样的，没区别，所以内核为了简化文件系统的开发，把这些通用的实现都抽象出来，变成 generic_file_read/write 之类的通用实现
static const struct file_operations shmem_file_operations = { /* 普通文件的读、写、seek、fsync */
.mmap = shmem_mmap,
.get_unmapped_area = shmem_get_unmapped_area,
#ifdef CONFIG_TMPFS
.llseek = shmem_file_llseek,
.read_iter = shmem_file_read_iter,
.write_iter = generic_file_write_iter,
.fsync = noop_fsync,
.splice_read = generic_file_splice_read,
.splice_write = iter_file_splice_write,
.fallocate = shmem_fallocate,
#endif
};
static const struct inode_operations shmem_inode_operations = { /* 这个是针对普通文件的 inode 操作 */
.getattr = shmem_getattr,
.setattr = shmem_setattr,
};
static const struct inode_operations shmem_dir_inode_operations = { /* 这个是针对目录的 inode 操作 */
#ifdef CONFIG_TMPFS
.create = shmem_create,
.lookup = simple_lookup,
.link = shmem_link,
.unlink = shmem_unlink,
.symlink = shmem_symlink,
.mkdir = shmem_mkdir,
.rmdir = shmem_rmdir,
.mknod = shmem_mknod,
.rename = shmem_rename2,
.tmpfile = shmem_tmpfile,
#endif
};
2.2. 文件创建过程
创建一个 tmpfs 数据文件
内核代码：shmem_create -> shmem_mknod
static int shmem_create(struct inode *dir, struct dentry *dentry, umode_t mode,
bool excl)
{
return shmem_mknod(dir, dentry, mode | S_IFREG, 0); /* S_IFREG 表明是创建的文件，如果是目录，那就是 S_IFDIR */
}
再来看下 shmem_mknode() 函数的实现，非常简单
/*
* File creation. Allocate an inode, and we're done..
*/
static int
shmem_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
{
struct inode *inode;
int error = -ENOSPC;
/* 这里先 new 一个新的 inode，然后挂到 sb 里面管理起来，sb的数据也完全是在内存里面 */
inode = shmem_get_inode(dir->i_sb, dir, mode, dev, VM_NORESERVE);
if (inode) {
error = simple_acl_create(dir, inode);
if (error)
goto out_iput;
error = security_inode_init_security(inode, dir,
&dentry->d_name,
shmem_initxattrs, NULL);
if (error && error != -EOPNOTSUPP)
goto out_iput;
error = 0;
/* 目录的 size，其实就是目录下所有 inode 空间的总和
* 注意：目录也是一个特殊的文件，文件的内容存储的是子目录的索引 */
dir->i_size += BOGO_DIRENT_SIZE;
dir->i_ctime = dir->i_mtime = current_time(dir);
/* 把新建的 inode 和 dentry 关联起来 */
d_instantiate(dentry, inode);
dget(dentry); /* Extra count - pin the dentry in core */
}
return error;
out_iput:
iput(inode);
return error;
}
2.3. 文件读写过程
用户台的文件读写，默认情况下都是 buffer 模式，也就是写 page cache，再由内核把 dirty page 刷到磁盘上
只有在真正的把文件落盘时，我们才需要真正的理解 file system 的底层结构，才需要知道把文件数据具体写到哪个磁盘 block 上
由于 tmpfs 数据不是存在物理磁盘上的，完全在内存，因此 tmpfs 的文件读写，完全是一个读写 page cache 的过程
内核为 tmpfs 构造了一个特殊的 address_space，写 page cache 就通过这个 address_space 来完成
1）读过程
内核调用栈：
shmem_file_read_iter
-> shmem_getpage -> shmem_getpage_gfp -> find_lock_entry -> find_get_entry：从 address_space 的 cache 里获取 page 缓存页
-> copy_page_to_iter：拷贝到用户空间
static ssize_t shmem_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
{
struct file *file = iocb->ki_filp;
struct inode *inode = file_inode(file);
struct address_space *mapping = inode->i_mapping;
/* ... */
index = *ppos >> PAGE_SHIFT;
offset = *ppos & ~PAGE_MASK;
for (;;) {
/* ... */
error = shmem_getpage(inode, index, &page, sgp);
if (error) {
if (error == -EINVAL)
error = 0;
break;
}
/* ... */
/*
* Ok, we have the page, and it's up-to-date, so
* now we can copy it to user space...
*/
ret = copy_page_to_iter(page, offset, nr, to);
/* ... */
}
/* ... */
}
2）写过程
xxx
3. tmpfs 内存的内核态管理
3.1. tmpfs 内存限制
tmpfs 内存受2个地方限制
一个是 mount 挂载文件系统的时候，会指定 tmpfs 的大小，如果超过这个限制，会写失败
第二个限制是，由于 tmpfs 的底层就是内存空间，不是磁盘，如果一个容器设置了 memory.max，硬限，那也会触发这个限制。当然，这个限制是间接的
3.2. tmpfs 内存统计
由于 tmpfs 数据并不直接落物理磁盘，所有数据都是在内存中以 page cache 的形式存在的，因此，容器中 tmpfs 的内存占用会统计到2个地方：
- page cache
- shmem
如下：如果我写一个100m的文件到 tmpfs 下面，cgroup 会把这个空间统计到 cache 和 shmem 里面
cat /sys/fs/cgroup/memory/test/memory.stat cache 104890368 rss 12288 rss_huge 0 shmem 104755200 mapped_file 0 dirty 0 writeback 0 pgpgin 25905 pgpgout 284
从 mm/memcontrol.c 代码中，我们知道 shmem 这项内存是保存在 stat[NR_SHMEM] 结构中的
static int memory_stat_show(struct seq_file *m, void *v)
{
/* ... */
seq_printf(m, "anon %llu\n",
(u64)stat[MEMCG_RSS] * PAGE_SIZE);
seq_printf(m, "file %llu\n",
(u64)stat[MEMCG_CACHE] * PAGE_SIZE);
seq_printf(m, "shmem %llu\n",
(u64)stat[NR_SHMEM] * PAGE_SIZE); // 这里
seq_printf(m, "file_mapped %llu\n",
(u64)stat[NR_FILE_MAPPED] * PAGE_SIZE);
seq_printf(m, "file_dirty %llu\n",
(u64)stat[NR_FILE_DIRTY] * PAGE_SIZE);
seq_printf(m, "file_writeback %llu\n",
(u64)stat[NR_WRITEBACK] * PAGE_SIZE);
/* ... */
}
mm/shmem.c 文件读写的时候，什么时候会把文件大小计数在这里呢？
shmem_add_to_page_cache 这个函数
/*
* Like add_to_page_cache_locked, but error if expected item has gone.
*/
static int shmem_add_to_page_cache(struct page *page,
struct address_space *mapping,
pgoff_t index, void *expected)
{
int error, nr = hpage_nr_pages(page);
/* ... */
if (!error) {
mapping->nrpages += nr;
if (PageTransHuge(page))
__inc_node_page_state(page, NR_SHMEM_THPS);
__mod_node_page_state(page_pgdat(page), NR_FILE_PAGES, nr);
__mod_node_page_state(page_pgdat(page), NR_SHMEM, nr); /* 这里 */
spin_unlock_irq(&mapping->tree_lock);
} else {
page->mapping = NULL;
spin_unlock_irq(&mapping->tree_lock);
page_ref_sub(page, nr);
}
return error;
}
同样，当 tmpfs 文件被删除时，shmem_delete_from_page_cache 函数会把这个计数器减掉被删除的文件大小
3.3. tmpfs 内存的分配和回收（page cache回收）
除非开了 swap 的情况下，swap 一般生产环境线上服务器是不打开的，因此这里不讨论
tmpfs 的内存虽然是 page cache，但是永远不会被回收，这是怎么做到的？
1）先说说分配过程
tmpfs 文件的 page cache 在分配的时候，会打上1个特殊的标记：__SetPageSwapBacked()，对应 PG_SwapBacked
__SetPageLocked() 这个函数不用管它
static struct page *shmem_alloc_and_acct_page(gfp_t gfp,
struct inode *inode,
pgoff_t index, bool huge)
{
struct shmem_inode_info *info = SHMEM_I(inode);
struct page *page;
int nr;
int err = -ENOSPC;
if (!IS_ENABLED(CONFIG_TRANSPARENT_HUGE_PAGECACHE))
huge = false;
nr = huge ? HPAGE_PMD_NR : 1;
if (!shmem_inode_acct_block(inode, nr))
goto failed;
if (huge)
page = shmem_alloc_hugepage(gfp, info, index);
else
page = shmem_alloc_page(gfp, info, index);
if (page) { /* 这里 */
__SetPageLocked(page);
__SetPageSwapBacked(page);
return page;
}
err = -ENOMEM;
shmem_inode_unacct_blocks(inode, nr);
failed:
return ERR_PTR(err);
}
除此之外，一旦这个 page 被写入任何数据，这个 page 就会被 vfs 标记为 PG_dirty
有了 PG_dirty 和 PG_SwapBacked 这2个标记之后，如果没有开启 swap 分区，tmpfs 的文件是没法回收的，必须常驻内存（可以理解）
（特别注意，也就是说 tmpfs 的 page 在内核里面，永远都是 dirty 状态
2）再看看 page cache 回收的过程
内核代码 mm/vmscan.c
函数 shrink_page_list
pageout() 函数写交换分区，这个函数有4个返回值：
- PAGE_KEEP：写page失败
- PAGE_ACTIVATE：表示page需要迁移回到活跃LRU链表中
- PAGE_SUCCESS：表示 page 已经成功写入存储设备
- PAGE_CLEAN：表示 page 已经是干净的，可以释放
page 回收的过程是：
shrink_page_list -> if (PageDirty(page)) { … } -> pageout() -> shmem_writepage() -> get_swap_page()，由于机器 swap 分区关闭，所以 get_swap_page 失败，返回 PAGE_ACTIVATE
4. tmpfs 内存的 Pod 共享
xx