Linux内核文件系统模块深度分析

原创于 2026-01-10 08:00:00 发布 · 置顶 · 885 阅读

24 ·

CC 4.0 BY-SA版权

文章标签：

#linux #鸿蒙系统 #系统架构 #系统安全

Linux 同时被 3 个专栏收录

27 篇文章

订阅专栏

Linux Kernel

25 篇文章

订阅专栏

Linux 驱动

19 篇文章

订阅专栏

团队博客: 汽车电子社区

概述

fs模块是Linux内核的虚拟文件系统（VFS）和具体文件系统实现，负责管理系统的存储和文件访问。这个模块的设计体现了现代操作系统的文件系统抽象原则，通过统一的接口支持多种文件系统类型。本文将从软件架构、调用流程和源码分析三个维度，深入剖析fs模块的设计理念和实现机制。

1. 软件架构分析

1.1 整体架构设计

fs模块采用分层架构设计，主要分为虚拟文件系统层、具体文件系统层、缓存层和设备接口层。这种设计确保了文件系统的统一性和可扩展性。

1.2 核心架构组件

1.2.1 虚拟文件系统层（VFS）

VFS层为用户空间提供统一的文件系统接口：

- 路径解析: fs/namei.c - 路径名到inode的转换
- inode管理: fs/inode.c - 索引节点的分配和管理
- 目录缓存: fs/dcache.c - 目录项的高效缓存
- 超级块管理: fs/super.c - 文件系统的超级块操作
- 文件表管理: fs/file_table.c - 打开文件的描述符表
- 文件锁: fs/locks.c - 文件和记录锁机制

VFS层是整个文件系统的核心抽象层，为上层提供统一的接口。

1.2.2 具体文件系统层

具体文件系统层实现了各种类型的文件系统：

- EXT4: fs/ext4/ - Linux的标准日志文件系统
- XFS: fs/xfs/ - 高性能的日志文件系统
- Btrfs: fs/btrfs/ - 现代化的写时复制文件系统
- PROC: fs/proc/ - 进程和系统信息的虚拟文件系统
- SYSFS: fs/sysfs/ - 内核对象和属性的虚拟文件系统
- NFS: fs/nfs/ - 网络文件系统客户端
- CIFS: fs/cifs/ - Windows/SMB网络文件系统

每个文件系统都实现了VFS定义的标准接口。

1.2.3 缓存层

缓存层通过多层缓存提高文件系统的性能：

- 块缓冲区: fs/buffer.c - 块设备的I/O缓冲
- 页缓存: mm/filemap.c - 文件内容的页面缓存
- 目录项缓存: fs/dcache.c - 路径名解析的快速缓存
- inode缓存: fs/inode.c - 索引节点的内存缓存

缓存层是文件系统性能的关键，通过缓存减少对底层设备的访问。

1.3 架构设计原则

fs模块的设计遵循以下核心原则：

1. 统一接口: 通过VFS提供一致的文件系统接口
2. 可扩展性: 易于添加新的文件系统类型
3. 性能优化: 多层缓存机制提高访问性能
4. 一致性: 确保不同文件系统的一致行为
5. 安全性: 提供文件访问的安全保护机制

2. 调用流程分析

2.1 文件打开调用流程

从open系统调用到文件可用的完整流程：

2.2 文件读写调用流程

文件读写操作的完整流程：

2.3 路径解析流程

路径名到inode的解析流程：

3. 源码深度分析

3.1 核心数据结构分析

3.1.1 超级块结构

// include/linux/fs.h
struct super_block {
    struct list_head s_list;         /* 超级块链表 */
    dev_t s_dev;                    /* 设备号 */
    unsigned char s_blocksize_bits;   /* 块大小的位表示 */
    unsigned long s_blocksize;        /* 块大小 */
    unsigned long s_old_blocksize;    /* 旧块大小 */
    loff_t s_maxbytes;              /* 最大文件大小 */
    struct file_system_type *s_type;  /* 文件系统类型 */
    const struct super_operations *s_op; /* 超级块操作 */
    struct dentry *s_root;          /* 根目录项 */
    struct rw_semaphore s_umount;     /* 卸载信号量 */
    struct mutex s_lock;             /* 超级块锁 */
    
    /* 统计信息 */
    int s_count;                    /* 引用计数 */
    atomic_t s_active;              /* 活动计数 */
    
    /* 文件系统特定信息 */
    void *s_fs_info;               /* 文件系统私有数据 */
    fmode_t s_mode;                /* 文件系统模式 */
    
    /* 挂载相关 */
    struct mount *s_mounts;         /* 挂载点列表 */
    struct block_device *s_bdev;    /* 块设备 */
    char s_id[32];                  /* 文件系统标识 */
    
    /* 时间戳 */
    struct timespec64 s_time_gran;   /* 时间粒度 */
    time64_t s_time_min;            /* 最小时间 */
    time64_t s_time_max;            /* 最大时间 */
    
    /* 杂项 */
    void *s_fs_info;               /* 文件系统信息 */
    struct hlist_bl_head s_anon;   /* 匿名inode列表 */
    struct list_head s_inodes;      /* inode列表 */
    struct list_head s_dentrys;     /* dentry列表 */
    struct list_head s_instances;    /* 文件系统实例 */
    
    /* 安全相关 */
    struct security_mnt_opts s_security_opts; /* 安全选项 */
    const struct xattr_handler **s_xattr; /* 扩展属性处理 */
    
    /* 文件系统标志 */
    unsigned long s_flags;          /* 超级块标志 */
    unsigned long s_iflags;         /* 内部标志 */
    unsigned long s_magic;         /* 魔数 */
    
    /* UUID和标签 */
    char s_uuid[16];               /* UUID */
    char s_fsname[32];             /* 文件系统名称 */
    
    /* 配额 */
    struct quota_info s_dquot;      /* 配额信息 */
    
    /* 加密 */
    struct fscrypt_info *s_crypt_info; /* 加密信息 */
};

super_block结构体描述一个已挂载的文件系统：

1. 设备信息: 设备号、块设备、块大小等
2. 操作接口: 文件系统类型的操作函数指针
3. 根目录: 文件系统的根目录项
4. 统计信息: 引用计数、活动计数等
5. 时间支持: 时间粒度和范围限制
6. 安全机制: 扩展属性和安全选项
7. 功能标志: 文件系统支持的功能

3.1.2 inode结构

// include/linux/fs.h
struct inode {
    umode_t i_mode;                 /* 文件模式和类型 */
    unsigned short i_opflags;         /* 操作标志 */
    kuid_t i_uid;                   /* 用户ID */
    kgid_t i_gid;                   /* 组ID */
    unsigned int i_flags;             /* 文件标志 */
    
    /* 文件系统私有数据 */
    struct hlist_node i_hash;         /* 哈希链表节点 */
    struct list_head i_list;          /* inode链表 */
    struct list_head i_sb_list;       /* 超级块链表 */
    struct list_head i_wb_list;       /* 写回链表 */
    struct hlist_node i_hash;         /* 哈希链表 */
    struct list_head i_lru;           /* LRU链表 */
    
    /* 时间戳 */
    struct timespec64 i_atime;        /* 访问时间 */
    struct timespec64 i_mtime;        /* 修改时间 */
    struct timespec64 i_ctime;        /* 状态改变时间 */
    struct timespec64 i_btime;        /* 创建时间 */
    
    /* 文件大小和块信息 */
    loff_t i_size;                   /* 文件大小 */
    blkcnt_t i_blocks;               /* 块数 */
    __u32 i_blkbits;                 /* 块大小的位表示 */
    
    /* 设备号 */
    dev_t i_rdev;                    /* 设备号 */
    
    /* 硬链接 */
    unsigned int i_nlink;             /* 硬链接数 */
    
    /* UID/GID映射 */
    struct posix_acl *i_acl;          /* ACL访问控制 */
    struct posix_acl *i_default_acl;  /* 默认ACL */
    
    /* 文件系统操作 */
    const struct inode_operations *i_op; /* inode操作 */
    const struct file_operations *i_fop; /* 文件操作 */
    struct super_block *i_sb;         /* 所属超级块 */
    
    /* 文件系统私有数据 */
    void *i_private;                 /* 私有数据 */
    
    /* 加密 */
    struct fscrypt_info *i_crypt_info; /* 加密信息 */
    
    /* 状态标志 */
    unsigned long i_state;            /* inode状态 */
    unsigned long dirtied_when;      /* 脏页时间 */
    
    /* 写回相关 */
    struct writeback_control i_wb;     /* 写回控制 */
    struct list_head i_io_list;       /* I/O列表 */
    
    /* 锁 */
    struct rw_semaphore i_rwsem;       /* 读写锁 */
    spinlock_t i_lock;               /* 自旋锁 */
    
    /* 引用计数 */
    atomic_t i_count;                /* 引用计数 */
    atomic_t i_dio_count;           /* 直接I/O计数 */
    
    /* 块映射 */
    struct address_space *i_mapping;   /* 地址空间 */
    
    /* 文件系统特定 */
    union {
        struct pipe_inode_info *i_pipe;     /* 管道 */
        struct block_device *i_bdev;        /* 块设备 */
        struct cdev *i_cdev;               /* 字符设备 */
    };
};

inode结构体表示文件系统中的一个文件或目录：

1. 文件属性: 模式、所有者、权限、时间戳
2. 文件内容: 大小、块数、地址空间映射
3. 文件系统信息: 所属超级块、操作接口
4. 缓存管理: LRU链表、写回机制
5. 安全机制: ACL、加密信息
6. 锁机制: 并发访问的保护

3.1.3 目录项结构

// include/linux/dcache.h
struct dentry {
    unsigned int d_flags;             /* 目录项标志 */
    seqcount_t d_seq;               /* 序列计数 */
    struct hlist_bl_node d_hash;     /* 哈希链表节点 */
    struct dentry *d_parent;         /* 父目录项 */
    struct qstr d_name;             /* 目录名 */
    struct inode *d_inode;           /* 关联的inode */
    unsigned char d_iname[DNAME_INLINE_LEN_MIN]; /* 内联名称 */
    
    /* LRU管理 */
    struct list_head d_lru;          /* LRU链表节点 */
    
    /* 子目录管理 */
    struct list_head d_subdirs;      /* 子目录列表 */
    struct hlist_head d_children;     /* 子目录哈希 */
    struct list_head d_u;            /* 别名链表 */
    
    /* 引用计数 */
    struct rcu_head d_rcu;          /* RCU头 */
    struct dentry_operations *d_op;   /* 目录项操作 */
    struct super_block *d_sb;         /* 超级块 */
    unsigned long d_time;            /* 时间戳 */
    void *d_fsdata;                 /* 文件系统私有数据 */
    
    /* 引用计数 */
    atomic_t d_count;               /* 引用计数 */
    
    /* 状态 */
    int d_mounted;                  /* 挂载点计数 */
    enum {
        D_UNRESOLVED,
        D_RESOLVED,
        D_RESOLVED_NEGATIVE,
        D_RESOLVED_BAD
    } d_status;                     /* 解析状态 */
};

dentry结构体表示路径名中的一个目录项：

1. 路径信息: 目录名、父目录、inode
2. 哈希管理: 哈希链表用于快速查找
3. 缓存管理: LRU链表用于缓存回收
4. 别名处理: 支持硬链接和符号链接
5. 状态管理: 解析状态和挂载点信息

3.2 关键函数实现分析

3.2.1 路径解析核心函数

// fs/namei.c
int path_lookupat(int dfd, const char __user *name,
                unsigned int flags, struct path *path)
{
    struct nameidata nd;
    int err;
    
    /* 初始化nameidata */
    nd->flags = flags;
    nd->dfd = dfd;
    nd->path = get_fs_pwd(current->fs);
    nd->inode = nd->path.dentry->d_inode;
    nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
    
    /* 路径解析 */
    err = link_path_walk(name, &nd);
    if (!err) {
        /* 路径解析成功 */
        path->dentry = nd->dentry;
        path->mnt = nd->mnt;
        return 0;
    }
    
    return err;
}

static int link_path_walk(const char *name, struct nameidata *nd)
{
    struct qstr last;
    int err;
    
    while (*name == '/')
        name++;
    
    if (!*name)
        return 0;
    
    /* 解析路径组件 */
    for (;;) {
        char c;
        const char *this_name;
        
        /* 处理路径分隔符 */
        while (*name == '/')
            name++;
        
        if (!*name)
            break;
        
        this_name = name;
        
        /* 查找下一个路径分隔符 */
        while ((c = *name++) != '\0' && c != '/')
            ;
        
        /* 设置当前组件 */
        last.name = this_name;
        last.len = name - this_name - 1;
        last.hash = full_name_hash(nd, this_name, last.len);
        
        /* 处理当前路径组件 */
        err = walk_component(nd, &last, LOOKUP_FOLLOW);
        if (err)
            break;
    }
    
    return err;
}

static int walk_component(struct nameidata *nd, struct qstr *name,
               int flags)
{
    struct dentry *dentry;
    struct inode *inode;
    int err;
    
    /* 在目录缓存中查找 */
    dentry = d_lookup(nd->dentry, name);
    
    if (!dentry) {
        /* 缓存未命中，从文件系统查找 */
        dentry = real_lookup(nd->dentry, name, &nd->flags);
        if (IS_ERR(dentry))
            return PTR_ERR(dentry);
    }
    
    /* 检查权限 */
    if (nd->inode) {
        err = inode_permission(nd->inode, MAY_EXEC);
        if (err)
            return err;
    }
    
    /* 检查是否需要跟随 */
    if (dentry->d_inode && S_ISLNK(dentry->d_inode->i_mode)) {
        if (flags & LOOKUP_FOLLOW) {
            /* 处理符号链接 */
            err = follow_link(nd, dentry);
            if (err)
                return err;
            return 0;
        }
    }
    
    /* 更新nameidata */
    nd->dentry = dentry;
    nd->inode = dentry->d_inode;
    nd->seq = read_seqcount_begin(&dentry->d_seq);
    
    return 0;
}

路径解析实现了高效的路径名转换：

1. 路径分割: 将路径分解为多个组件
2. 缓存查找: 优先在目录缓存中查找
3. 权限检查: 验证每个组件的访问权限
4. 符号链接: 处理符号链接的跟随
5. 状态维护: 维护解析过程中的状态信息

3.2.2 文件打开核心函数

// fs/open.c
long do_sys_open(int dfd, const char __user *filename,
         int flags, umode_t mode)
{
    struct open_flags op;
    int fd = build_open_flags(flags, mode, &op);
    struct filename *tmp;
    struct file *f;
    
    /* 获取文件名 */
    tmp = getname(filename);
    if (IS_ERR(tmp))
        return PTR_ERR(tmp);
    
    /* 分配文件描述符 */
    fd = get_unused_fd_flags(op.open_flag);
    if (fd < 0) {
        putname(tmp);
        return fd;
    }
    
    /* 打开文件 */
    f = do_filp_open(dfd, tmp, &op);
    if (IS_ERR(f)) {
        put_unused_fd(fd);
        putname(tmp);
        return PTR_ERR(f);
    }
    
    /* 安装文件 */
    fsnotify_open(f);
    fd_install(fd, f);
    
    putname(tmp);
    return fd;
}

struct file *do_filp_open(int dfd, struct filename *pathname,
                struct open_flags *op)
{
    struct path path;
    struct file *file;
    int error;
    
    /* 路径查找 */
    error = path_lookupat(dfd, pathname->name, op->lookup_flags, &path);
    if (error)
        return ERR_PTR(error);
    
    /* 检查创建标志 */
    if (op->intent & LOOKUP_CREATE) {
        error = may_create_at(path.dentry, op->mode);
        if (error)
            goto out_path_put;
    }
    
    /* 获取文件操作 */
    error = -ENOENT;
    if (!path.dentry->d_inode)
        goto out_path_put;
    
    /* 创建file结构 */
    file = get_empty_filp();
    if (!file) {
        error = -ENFILE;
        goto out_path_put;
    }
    
    /* 初始化file结构 */
    file->f_path = path;
    file->f_inode = path.dentry->d_inode;
    file->f_mapping = path.dentry->d_inode->i_mapping;
    file->f_flags = op->open_flag;
    file->f_mode = FMODE_READ | FMODE_WRITE;
    
    /* 设置文件操作 */
    if (path.dentry->d_inode->i_fop)
        file->f_op = path.dentry->d_inode->i_fop;
    else
        file->f_op = &def_chr_fops;
    
    /* 调用文件系统的open方法 */
    if (file->f_op->open) {
        error = file->f_op->open(path.dentry, file);
        if (error)
            goto out_release;
    }
    
    return file;
    
out_release:
    put_filp(file);
out_path_put:
    path_put(&path);
    return ERR_PTR(error);
}

文件打开实现了完整的打开流程：

1. 标志处理: 解析和处理打开标志
2. 路径查找: 转换路径名为inode
3. 权限检查: 验证文件访问权限
4. 文件对象: 创建和初始化file结构
5. 文件系统调用: 调用具体文件系统的open方法

3.2.3 EXT4文件系统实现

// fs/ext4/inode.c
static int ext4_iget(struct inode *inode, ino_t ino)
{
    struct ext4_inode_info *ei = EXT4_I(inode);
    struct buffer_head *bh;
    struct ext4_inode *raw_inode;
    struct super_block *sb = inode->i_sb;
    
    /* 计算inode位置 */
    ei->i_block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
    ei->i_ino_group = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
    
    /* 读取inode表 */
    bh = sb_bread(sb, ext4_inode_table(sb, ei->i_block_group) +
               ei->i_ino_group / EXT4_INODES_PER_BLOCK(sb));
    if (!bh)
        return -EIO;
    
    /* 获取原始inode */
    raw_inode = ext4_raw_inode(sb, bh, ei->i_ino_group);
    
    /* 填充VFS inode */
    inode->i_mode = le16_to_cpu(raw_inode->i_mode);
    inode->i_uid = le32_to_cpu(raw_inode->i_uid);
    inode->i_gid = le32_to_cpu(raw_inode->i_gid);
    inode->i_nlink = le16_to_cpu(raw_inode->i_links_count);
    inode->i_size = le32_to_cpu(raw_inode->i_size);
    
    /* 处理大文件 */
    if (S_ISREG(inode->i_mode) && inode->i_size > 0) {
        ei->i_dir_acl = le32_to_cpu(raw_inode->i_dir_acl);
        if (ei->i_dir_acl)
            inode->i_size |= ((u64)le32_to_cpu(raw_inode->i_size_high)) << 32;
    }
    
    /* 设置时间戳 */
    inode->i_atime.tv_sec = le32_to_cpu(raw_inode->i_atime);
    inode->i_ctime.tv_sec = le32_to_cpu(raw_inode->i_ctime);
    inode->i_mtime.tv_sec = le32_to_cpu(raw_inode->i_mtime);
    
    /* 设置操作函数 */
    if (S_ISREG(inode->i_mode))
        inode->i_fop = &ext4_file_operations;
    else if (S_ISDIR(inode->i_mode))
        inode->i_fop = &ext4_dir_operations;
    else if (S_ISLNK(inode->i_mode))
        inode->i_fop = &ext4_symlink_inode_operations;
    
    /* 设置inode操作 */
    inode->i_op = &ext4_inode_operations;
    
    brelse(bh);
    return 0;
}

static int ext4_readpage(struct file *file, struct page *page)
{
    struct inode *inode = page->mapping->host;
    struct ext4_inode_info *ei = EXT4_I(inode);
    struct buffer_head *bh;
    void *data;
    int err;
    
    /* 检查页面是否在缓存中 */
    if (PageUptodate(page))
        return 0;
    
    /* 分配缓冲区 */
    data = kmap(page);
    bh = ext4_getblk(inode, page->index);
    if (!bh) {
        err = -EIO;
        goto out;
    }
    
    /* 读取块数据 */
    err = ext4_read_block(bh);
    if (err)
        goto out_bh;
    
    /* 复制数据到页面 */
    memcpy(data, bh->b_data, PAGE_SIZE);
    
    /* 标记页面为最新 */
    SetPageUptodate(page);
    unlock_page(page);
    
out_bh:
    brelse(bh);
out:
    kunmap(page);
    return err;
}

EXT4实现了高效的文件系统操作：

1. inode管理: 高效的inode读取和管理
2. 大文件支持: 支持大文件和扩展属性
3. 日志功能: 支持数据一致性和恢复
4. 缓存优化: 利用页缓存和块缓存
5. 扩展属性: 支持ACL、加密等扩展功能

4. 性能优化机制

4.1 缓存优化

4.1.1 目录缓存优化

// fs/dcache.c
static struct dentry *d_lookup(struct dentry *parent, struct qstr *name)
{
    struct hlist_bl_head *b;
    struct dentry *found = NULL;
    struct hlist_bl_node *node;
    unsigned int seq;
    
    b = d_hash(parent, name->hash);
    
    /* 读取锁保护哈希查找 */
    seq = read_seqcount_begin(&parent->d_seq);
    
    hlist_bl_for_each_entry_rcu(node, b, d_hash) {
        struct dentry *dentry = hlist_bl_entry(node, struct dentry, d_hash);
        
        if (dentry->d_name.hash != name->hash)
            continue;
        
        if (dentry->d_parent != parent)
            continue;
        
        if (dentry_cmp(dentry, name))
            continue;
        
        found = dentry;
        break;
    }
    
    if (read_seqcount_retry(&parent->d_seq, seq))
        return NULL;
    
    return found;
}

目录缓存通过哈希表实现快速查找：

1. 哈希优化: 使用哈希表加速路径解析
2. RCU保护: 使用RCU提供无锁读取
3. 序列计数: 检测并发修改
4. 内联优化: 支持短名称的内联存储

4.1.2 页缓存优化

// mm/filemap.c
struct page *read_cache_page(struct address_space *mapping,
                pgoff_t index)
{
    struct page *page;
    
repeat:
    /* 在页缓存中查找 */
    page = find_get_page(mapping, index);
    if (page) {
        /* 页面在缓存中 */
        if (PageUptodate(page))
            return page;
        
        /* 等待页面读取完成 */
        wait_on_page_locked(page);
        if (PageUptodate(page))
            return page;
        
        page_cache_release(page);
        goto repeat;
    }
    
    /* 页面不在缓存中，分配新页面 */
    page = page_cache_alloc(mapping);
    if (!page)
        return ERR_PTR(-ENOMEM);
    
    /* 添加到页缓存 */
    error = add_to_page_cache_lru(page, mapping, index, GFP_KERNEL);
    if (error) {
        page_cache_release(page);
        return ERR_PTR(error);
    }
    
    /* 读取页面数据 */
    error = mapping->a_ops->readpage(file, page);
    if (error) {
        page_cache_release(page);
        return ERR_PTR(error);
    }
    
    return page;
}

页缓存通过LRU算法优化内存使用：

1. LRU管理: 基于LRU的页面替换策略
2. 预读机制: 预测性读取提高性能
3. 写回机制: 异步写回减少I/O延迟
4. 压缩支持: 对冷页面进行压缩存储

4.2 I/O优化

4.2.1 聚合I/O

// fs/ext4/inode.c
static ssize_t ext4_file_write_iter(struct kiocb *iocb,
                   struct iov_iter *from)
{
    struct file *file = iocb->ki_filp;
    struct inode *inode = file_inode(iocb->ki_filp);
    ssize_t written = 0;
    ssize_t ret;
    
    /* 检查文件大小限制 */
    if (iocb->ki_pos > EXT4_MAX_FILE_SIZE)
        return -EFBIG;
    
    /* 处理直接I/O */
    if (iocb->ki_flags & IOCB_DIRECT) {
        ret = ext4_direct_IO(iocb, from);
        return ret;
    }
    
    /* 处理缓冲I/O */
    while (iov_iter_count(from)) {
        ssize_t chunk;
        
        /* 分块写入 */
        chunk = ext4_buffered_write(iocb, from);
        if (chunk <= 0) {
            if (!written)
                written = chunk;
            break;
        }
        
        written += chunk;
        iocb->ki_pos += chunk;
    }
    
    return written;
}

聚合I/O通过合并小请求提高效率：

1. 请求合并: 合并相邻的I/O请求
2. 批量操作: 批量的数据读写操作
3. 异步I/O: 异步处理减少等待时间
4. 顺序优化: 优化顺序访问模式

5. 调试和诊断机制

5.1 文件系统调试

5.1.1 DebugFS支持

// fs/debugfs/inode.c
static struct dentry *debugfs_create_file(const char *name, umode_t mode,
                   struct dentry *parent, void *data,
                   const struct file_operations *fops)
{
    struct dentry *dentry;
    int error;
    
    /* 创建目录项 */
    dentry = debugfs_get_dentry(parent, name);
    if (IS_ERR(dentry))
        return dentry;
    
    /* 设置inode属性 */
    if (mode) {
        dentry->d_inode->i_mode = mode;
    } else {
        dentry->d_inode->i_mode = S_IFREG | S_IRUGO;
    }
    
    /* 设置文件操作 */
    dentry->d_inode->i_fop = fops;
    dentry->d_inode->i_private = data;
    
    return dentry;
}

DebugFS提供了内核调试接口：

1. 文件系统接口: 通过文件系统暴露调试信息
2. 动态创建: 支持动态创建和删除调试文件
3. 权限控制: 灵活的权限管理机制
4. 格式化输出: 支持各种格式的数据输出

5.1.2 性能统计

// include/linux/fs.h
struct file_system_type {
    const char *name;
    int fs_flags;
    struct dentry *(*mount) (struct file_system_type *, int,
                       const char *, void *);
    void (*kill_sb) (struct super_block *);
    struct module *owner;
    struct file_system_type * next;
    struct hlist_head fs_supers;
    
    /* 统计信息 */
    atomic_t active;
    atomic_t s_count;
    unsigned long s_flags;
};

void inc_fs_count(struct file_system_type *type)
{
    atomic_inc(&type->active);
}

void dec_fs_count(struct file_system_type *type)
{
    atomic_dec(&type->active);
}