uname -r

# 查看是否已加载overlay 模块
lsmod | grep overlay

# 若没有加载则可手动加载
modprobe overlay

# 直接继续overlay fs的挂载，自动加载overlay模块
mount -t overlay overlay -o lowerdir=/lower,upperdir=/upper,workdir=/work  /merged

# 该命令指定一个lower层，一个upper层
sudo mount -t overlay overlay -o lowerdir=/lower,upperdir=/upper,workdir=/work /merged

# 若需要指定多个lower层，可以使用如下命令
sudo mount -t overlay overlay -o lowerdir=/lower1:/lower2:/lower3,upperdir=/upper,workdir=/work  /merged

SYSCALL_DEFINE5(mount,,,,,,,) // fs/namespace.c
|-> user_path_at(AT_FDCWD, dir_name, LOOKUP_FOLLOW, &path);
|-> do_mount(kernel_dev, dir_name, kernel_type, flags, options);
    |-> path_mount(dev_name, &path, type_page, flags, data_page);
        |-> do_new_mount()
            | // (1) 找到指定文件系统
            |-> type = get_fs_type(fstype);
            |           |-> find_filesystem(name, len)
            |           |-> for (p = &file_systems; *p; p = &(*p)->next)
            |           |-> strncmp((*p)->name, name, len) == 0
            |           |-> return p;
            |
            | // (2) 创建fc
            |-> fc = fs_context_for_mount(type, sb_flags);
            |        |-> alloc_fs_context(fs_type, NULL, sb_flags, 0, FS_CONTEXT_FOR_MOUNT);
            |                |-> fc = kzalloc(sizeof(struct fs_context), GFP_KERNEL);
            |                |-> fc->fs_type    = get_filesystem(fs_type);
            |                |-> legacy_init_fs_context(fc);
            |                    |-> fc->fs_private = kzalloc(sizeof(struct legacy_fs_context), GFP_KERNEL);
            |                    |-> fc->ops = &legacy_fs_context_ops;
            |
            | // (3) 将fc的root指针指向overlayfs挂载点根root目录
            |-> vfs_get_tree(fc)
            |   | // 通过fc的get_tree间接调用文件系统mount函数，以获得挂载节点root目录项（记录在fc中）
            |   | // fc->ops->get_tree(fc); => legacy_get_tree
            |   |-> legacy_get_tree(fc) // 将挂载点的root目录项赋值到fc的root
            |       |-> root = fc->fs_type->mount(fc->fs_type, fc->sb_flags, fc->source, ctx->legacy_data);
            |       |-> fc->root = root; // struct dentry *
            |
            | // (4) 创建mount实体，并将其挂载到supper_block的挂载链表中
            |-> do_new_mount_fc(fc, path, mnt_flags)；// path的形参即为mountpoint，是实际文件系统中mount挂载目标路径
                |-> mnt = vfs_create_mount(fc);
                |         |-> mnt = alloc_vfsmnt(fc->source ?: "none");
                |         |-> mnt->mnt.mnt_sb       = fc->root->d_sb;
                |         |-> mnt->mnt.mnt_root = dget(fc->root);
                |         |-> mnt->mnt_mountpoint   = mnt->mnt.mnt_root;
                |         |-> mnt->mnt_parent       = mnt;
                |         |-> list_add_tail(&mnt->mnt_instance, &mnt->mnt.mnt_sb->s_mounts);
                |
                |-> do_add_mount(real_mount(mnt), mp, mountpoint, mnt_flags);

ovl_mount() // fs/overlayfs/super.c
|-> mount_nodev(fs_type, flags, raw_data, ovl_fill_super); // return "dentry* s_root"
    | // (1) 为新挂载点创建superblock
    |-> s = sget() // struct super_block *
    |       |-> s = alloc_super(type, (flags & ~SB_SUBMOUNT), user_ns); 
    |       |-> list_add_tail(&s->s_list, &super_blocks);
    |
    | // fill_super()
    |-> ovl_fill_super(s, data, flags & SB_SILENT ? 1 : 0)
        |-> struct ovl_fs *ofs; // private information held for overlayfs's superblock
        |-> struct ovl_layer *layers;
        |
        |-> ofs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL);
        |-> sb->s_d_op = &ovl_dentry_operations;
        |-> ovl_parse_opt((char *) data, &ofs->config);
        |-> numlower = ovl_split_lowerdirs(splitlower);
        |
        | // 创建联合文件系统层级数组
        |-> layers = kcalloc(numlower + 1, sizeof(struct ovl_layer), GFP_KERNEL);
        |-> ofs->layers = layers;
        |
        |-> sb->s_op = &ovl_super_operations;
        |
        | // 设置upperlayer：设置layer的trap执行upperpath目录的inode；依据upperpath在实际文件系统中的挂载点填充layer的挂载点（ovl挂载的root为实际文件系统中一指定目录）；
        |-> ovl_get_upper(sb, ofs, &layers[0], &upperpath);
        |   | // 获得upperlayer目录在实际文件系统上路径：若路径未打开过，则创建路径上的所有节点的dentry与inode
        |   |-> ovl_mount_dir(ofs->config.upperdir, upperpath);
        |   | // 为挂载点创建一个inode，保存在trap中：新inode的private数据指向实际文件系统中挂载点目录的inode
        |   |-> ovl_setup_trap(sb, upperpath->dentry, &upper_layer->trap,  "upperdir");
        |   | // 拷贝upper层实际文件系统路径的挂载点为虚拟堆叠文件系统一个层次的新mount节点，且新的mount节点的root目录为uppper目录；
        |   |-> upper_mnt = clone_private_mount(upperpath);
        |   |-> upper_layer->mnt = upper_mnt;
        |
        | // 创建workdir: workbasedir为指定的实际文件系统内的目录，workbasedir_trap对workbasedir的inode的trap；workdir为workbasedir下创建的默认名称为“work”的目录
        |-> ovl_get_workdir(sb, ofs, &upperpath);
        |   |-> ofs->workbasedir = dget(workpath.dentry);
        |   | // 申请一个ovl_inode，使其private指向实际文件系统inode，新对象地址保存在ofs->workbasedir_trap内
        |   |-> ovl_setup_trap(sb, ofs->workbasedir, &ofs->workbasedir_trap, "workdir");
        |   |
        |   |-> ovl_make_workdir(sb, ofs, &workpath);
        |
        | // 逐个获取lower层，检查是否已经有打上“trap”标记的inode，同时为每个lower层的root inode打上“trap”标记
        |-> oe = ovl_get_lowerstack(sb, splitlower, numlower, ofs, layers);
        |
        | // 对每个层对应root inode的parent递归检查是否已经打上“trap”标记，重叠层可能是互为祖先关系
        |-> ovl_check_overlapping_layers(sb, ofs);
        |
        |-> sb->s_fs_info = ofs;
        |
        |-> root_dentry = ovl_get_root(sb, upperpath.dentry, oe);
        |
        |-> sb->s_root = root_dentry;

ovl_get_upper(sb, ofs, &layers[0], &upperpath);
|-> struct vfsmount *upper_mnt;
| // （1）解析upper目录：沿着用户指定的upper目录路径解析，直至找到目录的目录项
|-> ovl_mount_dir(ofs->config.upperdir, upperpath);
|   |-> tmp = kstrdup(name, GFP_KERNEL);
|   |-> ovl_mount_dir_noesc(tmp, path);
|       |-> kern_path(name, LOOKUP_FOLLOW, path);
|           |-> filename_lookup(AT_FDCWD, getname_kernel(name), flags, path, NULL);
|
| // （2）设置upper_layer的trap：即从Overlayfs超级块新申请一个inode，并将upper目录的inode设置为其私有数据
|-> ovl_setup_trap(sb, upperpath->dentry, &upper_layer->trap,  "upperdir");
|   |-> trap = ovl_get_trap_inode(sb, dir);
|   |          |-> struct inode *key = d_inode(dir);
|   |          |-> struct inode *trap;
|   |          |-> trap = iget5_locked(sb, (unsigned long) key, ovl_inode_test, ovl_inode_set, key);
|   |          |-> return trap;
|   |-> *ptrap = trap;
|
| // （3）创建一个upper层目录挂载节点clone体，并赋值给upper_layer的mnt成员
|-> upper_mnt = clone_private_mount(upperpath);
|               |-> struct mount *old_mnt = real_mount(path->mnt);
|               |-> struct mount *new_mnt;
|               | // 创建一个upper层的mount节点的clone体，并且将其挂载到upper层超级块的挂载点链表上
|               |-> new_mnt = clone_mnt(old_mnt, path->dentry, CL_PRIVATE);
|               |             |-> struct super_block *sb = old->mnt.mnt_sb;
|               |             |-> struct mount *mnt;
|               |             |
|               |             |-> mnt = alloc_vfsmnt(old->mnt_devname);
|               |             |-> mnt->mnt.mnt_sb = sb;
|               |             |-> mnt->mnt.mnt_root = dget(root);
|               |             |-> list_add_tail(&mnt->mnt_instance, &sb->s_mounts);
|               |
|               |-> return &new_mnt->mnt;
|-> upper_layer->mnt = upper_mnt;

static struct ovl_entry *
ovl_get_lowerstack(struct super_block *sb, const char *lower, unsigned int numlower, struct ovl_fs *ofs, struct ovl_layer *layers)
|-> struct path *stack = NULL;
|-> struct ovl_entry *oe;
|
| // （1）分配并初始化深度与lower层目录树对应的path数组
|-> stack = kcalloc(numlower, sizeof(struct path), GFP_KERNEL);
|-> for (i = 0; i < numlower; i++) {
|       // 依次解析所有lower层目录
|->     err = ovl_lower_dir(lower, &stack[i], ofs, &sb->s_stack_depth);
|-> }
|
| // 根据lower层目录数组设置Overlayfs文件系统及其layers
|-> ovl_get_layers(sb, ofs, stack, numlower, layers);
|   |-> ofs->fs = kcalloc(numlower + 1, sizeof(struct ovl_sb), GFP_KERNEL);
|   |
|   |-> ofs->fs[0].sb = ovl_upper_mnt(ofs)->mnt_sb;
|   |-> ofs->fs[0].is_lower = false;
|   |
|   |-> for (i = 0; i < numlower; i++) {
|   |->     ovl_setup_trap(sb, stack[i].dentry, &trap, "lowerdir");
|   |->     mnt = clone_private_mount(&stack[i]);
|   |->     layers[ofs->numlayer].trap = trap;
|   |->     layers[ofs->numlayer].mnt = mnt;
|   |->     ofs->fs[fsid].is_lower = true;
|   |-> }
|
| // 设置overlayfs文件系统的根目录ovl_entry
|-> oe = ovl_alloc_entry(numlower);
|-> for (i = 0; i < numlower; i++) {
|->     oe->lowerstack[i].dentry = dget(stack[i].dentry);
|->     oe->lowerstack[i].layer = &ofs->layers[i+1];
|-> }
|
| // 释放临时存放lower层路径的path数组
|-> kfree(stack);
|-> return oe;

static struct dentry *
ovl_get_root(struct super_block *sb, struct dentry *upperdentry, struct ovl_entry *oe)
|-> struct dentry *root;
|-> struct ovl_path *lowerpath = &oe->lowerstack[0];
|-> struct ovl_inode_params oip = {
|->     .upperdentry = upperdentry,
|->     .lowerpath = lowerpath,
|-> };
|
|-> root = d_make_root(ovl_new_inode(sb, S_IFDIR, 0));
|-> root->d_fsdata = oe;
|
|-> ovl_inode_init(d_inode(root), &oip, ino, fsid);
|   |-> OVL_I(inode)->__upperdentry = oip->upperdentry;
|   |-> OVL_I(inode)->lower = igrab(d_inode(oip->lowerpath->dentry));
|
|-> ovl_dentry_update_reval(root, upperdentry, DCACHE_OP_WEAK_REVALIDATE);
|-> return root;