3. proc文件系统：procfs原理、创建proc文件、读写操作、实际应用案例

好，咱们今天来聊聊 proc 文件系统。说实话，这是内核与用户态通信里最经典、也最“古老”的一种方式了。我刚开始接触 Linux 内核时，第一个学会的就是用 cat /proc/cpuinfo 看 CPU 信息。但你有没有想过，这个 /proc 目录到底是怎么来的？它背后是什么原理？

3.1 procfs 原理：一个“虚拟”的文件系统

procfs，全称 Process File System。它不是一个真正的磁盘文件系统。它不存数据在硬盘上。它只存在于内存中。

说白了，/proc 下的每个文件，其实都是一个“钩子”。当你读它时，内核会调用一个函数，现场生成数据返回给你。当你写它时，内核会调用另一个函数，处理你写入的数据。

我个人习惯把 procfs 理解为“内核的调试窗口”。它让用户态程序能以一种非常自然的方式——读写文件——来获取内核内部的状态。

为什么会这样设计？嗯，因为 Linux 的设计哲学是“一切皆文件”。把内核信息暴露成文件，用户态程序用标准文件 I/O 就能访问，不需要额外的系统调用。这大大降低了编程门槛。

3.2 创建 proc 文件：从内核模块开始

创建 proc 文件，通常是在内核模块的初始化函数里完成的。我给大家看一个最简示例：

#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/uaccess.h>

static struct proc_dir_entry *my_proc_file;

static int __init my_proc_init(void) {
    // 创建一个名为 "my_test" 的 proc 文件
    my_proc_file = proc_create("my_test", 0666, NULL, &my_proc_fops);
    if (!my_proc_file) {
        pr_err("Failed to create /proc/my_test\n");
        return -ENOMEM;
    }
    pr_info("/proc/my_test created\n");
    return 0;
}

static void __exit my_proc_exit(void) {
    proc_remove(my_proc_file);
    pr_info("/proc/my_test removed\n");
}

module_init(my_proc_init);
module_exit(my_proc_exit);
MODULE_LICENSE("GPL");

这里有几个关键点：

• proc_create() 的第三个参数是父目录，传 NULL 表示直接挂在 /proc 下。
• 权限 0666 表示所有用户可读写。生产环境建议收紧权限。
• my_proc_fops 是 file_operations 结构体，它定义了读写回调。

3.3 读写操作：实现 file_operations

创建文件只是第一步。真正干活的是 file_operations 里的回调函数。我写一个完整的例子：

static ssize_t my_proc_read(struct file *file, char __user *buf,
                            size_t count, loff_t *ppos) {
    char msg[] = "Hello from kernel!\n";
    size_t len = strlen(msg);

    if (*ppos >= len)
        return 0;  // 文件读完

    if (count > len - *ppos)
        count = len - *ppos;

    if (copy_to_user(buf, msg + *ppos, count))
        return -EFAULT;

    *ppos += count;
    return count;
}

static ssize_t my_proc_write(struct file *file, const char __user *buf,
                             size_t count, loff_t *ppos) {
    char kernel_buf[128];

    if (count > sizeof(kernel_buf) - 1)
        count = sizeof(kernel_buf) - 1;

    if (copy_from_user(kernel_buf, buf, count))
        return -EFAULT;

    kernel_buf[count] = '\0';
    pr_info("User wrote: %s\n", kernel_buf);

    return count;
}

static struct file_operations my_proc_fops = {
    .owner = THIS_MODULE,
    .read = my_proc_read,
    .write = my_proc_write,
};

注意看 copy_to_user 和 copy_from_user。这是内核态和用户态之间拷贝数据的标准方式。我见过新手直接在内核里用 memcpy 操作用户态指针，结果导致内核崩溃。嗯，这里一定要用专用函数。

3.4 实际应用案例：一个简单的内核计数器

光讲理论没意思。我给大家展示一个实际案例：创建一个 proc 文件，用来读取和重置内核里的一个计数器。

假设我们有一个内核模块，它统计了某个事件发生的次数。我们想通过 /proc/counter 来查看当前计数，并且允许用户写入 reset 来清零。

static unsigned long event_count = 0;

static ssize_t counter_read(struct file *file, char __user *buf,
                            size_t count, loff_t *ppos) {
    char tmp[32];
    int len;

    len = snprintf(tmp, sizeof(tmp), "%lu\n", event_count);

    if (*ppos >= len)
        return 0;

    if (count > len - *ppos)
        count = len - *ppos;

    if (copy_to_user(buf, tmp + *ppos, count))
        return -EFAULT;

    *ppos += count;
    return count;
}

static ssize_t counter_write(struct file *file, const char __user *buf,
                             size_t count, loff_t *ppos) {
    char cmd[16];

    if (count > sizeof(cmd) - 1)
        count = sizeof(cmd) - 1;

    if (copy_from_user(cmd, buf, count))
        return -EFAULT;

    cmd[count] = '\0';

    // 去掉换行符
    if (cmd[count-1] == '\n')
        cmd[count-1] = '\0';

    if (strcmp(cmd, "reset") == 0) {
        event_count = 0;
        pr_info("Counter reset by user\n");
    } else {
        pr_warn("Unknown command: %s\n", cmd);
    }

    return count;
}

static struct file_operations counter_fops = {
    .owner = THIS_MODULE,
    .read = counter_read,
    .write = counter_write,
};

用户态操作很简单：

# 读取计数器
cat /proc/counter

# 重置计数器
echo "reset" > /proc/counter

你想想看，这种交互方式多直观。用户不需要写复杂的 ioctl 调用，也不需要了解内核 API。一个 echo 命令就搞定了。

3.5 知识体系结构图

下面我用一张 SVG 图来总结 procfs 的核心逻辑：

3.6 总结与建议

procfs 的优点很明显：简单、直观、无需额外工具。但它也有缺点：

• 每个 proc 文件只能处理简单的字符串数据。不适合传输二进制大数据。
• 大量 proc 文件会拖慢 ls /proc 的速度。我见过有人在一个模块里创建了几百个 proc 文件，结果每次 ls 都要卡几秒。
• 对于新开发的内核功能，内核社区更推荐使用 sysfs 或 debugfs。

好了，关于 procfs 就聊这么多。记住它的核心：虚拟文件、回调函数、copy_to/from_user。这三个概念抓住了，procfs 你就掌握了。

---