4. proc 文件系统调试：通过 /proc 接口查看驱动状态、创建自定义 /proc 条目

在嵌入式 Linux 驱动开发中，/proc 文件系统是一个虚拟文件系统，它提供了一种内核与用户空间通信的轻量级机制。驱动开发者可以通过 /proc 接口实时导出驱动内部状态、寄存器值、统计计数或配置参数，而无需依赖复杂的系统调用或 ioctl 接口。本章将深入讲解 /proc 文件系统的原理、标准调试方法以及如何为自定义驱动创建专属的 /proc 条目。

4.1 /proc 文件系统概述与驱动调试价值

/proc 文件系统挂载于 /proc 目录，其下的每个文件或目录对应内核中的一个回调函数。当用户态程序（如 cat、echo）读写这些文件时，内核会调用对应的处理函数，从而完成数据交换。

对于驱动调试，/proc 的核心价值体现在以下方面：

• 零依赖调试： 无需额外的调试工具或库，仅需 cat 和 echo 命令即可查看或修改驱动状态。
• 实时性： 每次读取都从内核数据结构中即时生成，反映当前硬件或软件状态。
• 低侵入性： 相比 printk，/proc 不会污染内核日志缓冲区，且只在需要时才产生开销。
• 结构化输出： 驱动可以按表格、列表或键值对格式组织输出，便于脚本解析。

4.2 标准 /proc 调试接口速查

Linux 内核已经提供了多个标准 /proc 条目，驱动开发者可以直接利用它们进行快速调试，无需编写任何额外代码。

4.3 创建自定义 /proc 条目：核心 API

为驱动创建自定义 /proc 条目，主要使用内核提供的 proc_create() 和 remove_proc_entry() 函数。以下是最常用的 API 及其功能：

4.4 实战：为字符设备驱动创建 /proc 状态条目

以下示例展示如何为一个虚拟字符设备驱动创建 /proc/mydrv_status 条目，用于导出驱动内部状态。该驱动模拟了一个具有缓冲区、打开计数和错误计数器的设备。

4.4.1 驱动状态结构体定义

/* mydrv.h */
struct mydrv_state {
    unsigned long   buffer_size;      /* 缓冲区大小 */
    atomic_t        open_count;       /* 当前打开次数 */
    atomic64_t      read_bytes;       /* 累计读取字节数 */
    atomic64_t      write_bytes;      /* 累计写入字节数 */
    unsigned int    error_count;      /* 错误计数 */
    spinlock_t      lock;             /* 保护状态的自旋锁 */
};

4.4.2 使用 seq_file 实现 proc_read 回调

seq_file 接口是内核推荐的方式，它通过 seq_printf() 逐行输出内容，自动处理大缓冲区分页问题。

/* mydrv_proc.c */
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/module.h>
#include "mydrv.h"

extern struct mydrv_state drv_state;  /* 全局驱动状态 */

/* seq_file 的 show 函数：每次调用输出一行 */
static int mydrv_proc_show(struct seq_file *m, void *v)
{
    unsigned long buf_size;
    unsigned int err_cnt;
    s64 rd_bytes, wr_bytes;
    int open_cnt;

    /* 加锁读取状态，保证一致性 */
    spin_lock(&drv_state.lock);
    buf_size  = drv_state.buffer_size;
    err_cnt   = drv_state.error_count;
    rd_bytes  = atomic64_read(&drv_state.read_bytes);
    wr_bytes  = atomic64_read(&drv_state.write_bytes);
    open_cnt  = atomic_read(&drv_state.open_count);
    spin_unlock(&drv_state.lock);

    /* 使用 seq_printf 输出格式化内容 */
    seq_printf(m, "Driver Status Report\n");
    seq_printf(m, "====================\n");
    seq_printf(m, "Buffer Size    : %lu bytes\n", buf_size);
    seq_printf(m, "Open Count     : %d\n", open_cnt);
    seq_printf(m, "Read Bytes     : %lld\n", rd_bytes);
    seq_printf(m, "Write Bytes    : %lld\n", wr_bytes);
    seq_printf(m, "Error Count    : %u\n", err_cnt);
    seq_printf(m, "Driver State   : %s\n",
               (drv_state.error_count > 10) ? "WARNING" : "OK");

    return 0;
}

/* seq_file 的 start/next/stop 回调（单条目文件可简化） */
static void *mydrv_proc_start(struct seq_file *m, loff_t *pos)
{
    return (*pos == 0) ? &drv_state : NULL;
}

static void *mydrv_proc_next(struct seq_file *m, void *v, loff_t *pos)
{
    (*pos)++;
    return NULL;
}

static void mydrv_proc_stop(struct seq_file *m, void *v)
{
    /* 无需清理 */
}

/* 定义 seq_file 操作集 */
static const struct seq_operations mydrv_seq_ops = {
    .start = mydrv_proc_start,
    .next  = mydrv_proc_next,
    .stop  = mydrv_proc_stop,
    .show  = mydrv_proc_show,
};

/* proc_open 回调：关联 seq_file */
static int mydrv_proc_open(struct inode *inode, struct file *file)
{
    return seq_open(file, &mydrv_seq_ops);
}

/* 定义 proc_ops 结构体（Linux 5.6+） */
static const struct proc_ops mydrv_proc_fops = {
    .proc_open    = mydrv_proc_open,
    .proc_read    = seq_read,
    .proc_lseek   = seq_lseek,
    .proc_release = seq_release,
};

4.4.3 模块加载/卸载时创建与移除条目

/* mydrv_main.c */
#include <linux/module.h>
#include <linux/proc_fs.h>
#include "mydrv.h"

struct mydrv_state drv_state;
static struct proc_dir_entry *mydrv_proc_entry;

#define PROC_NAME "mydrv_status"

static int __init mydrv_init(void)
{
    int ret;

    /* 初始化驱动状态 */
    spin_lock_init(&drv_state.lock);
    atomic_set(&drv_state.open_count, 0);
    atomic64_set(&drv_state.read_bytes, 0);
    atomic64_set(&drv_state.write_bytes, 0);
    drv_state.buffer_size = 4096;
    drv_state.error_count = 0;

    /* 创建 /proc/mydrv_status 条目 */
    mydrv_proc_entry = proc_create(PROC_NAME, 0444, NULL, &mydrv_proc_fops);
    if (!mydrv_proc_entry) {
        pr_err("Failed to create /proc/%s\n", PROC_NAME);
        ret = -ENOMEM;
        goto err_proc;
    }

    pr_info("mydrv: loaded, /proc/%s created\n", PROC_NAME);
    return 0;

err_proc:
    return ret;
}

static void __exit mydrv_exit(void)
{
    /* 移除 /proc 条目 */
    if (mydrv_proc_entry)
        remove_proc_entry(PROC_NAME, NULL);

    pr_info("mydrv: unloaded\n");
}

module_init(mydrv_init);
module_exit(mydrv_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Example driver with /proc status interface");

4.5 实现 proc_write：通过 /proc 动态控制驱动

/proc 条目不仅可读，还可以支持写操作，用于动态调整驱动参数。例如，通过写入 /proc/mydrv_status 来重置错误计数或调整缓冲区大小。

/* 在 mydrv_proc.c 中添加写回调 */
static ssize_t mydrv_proc_write(struct file *file,
                                const char __user *buffer,
                                size_t count, loff_t *pos)
{
    char buf[64];
    unsigned long val;
    int ret;

    /* 限制写入长度，防止缓冲区溢出 */
    if (count > sizeof(buf) - 1)
        count = sizeof(buf) - 1;

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

    buf[count] = '\0';

    /* 解析命令：支持 "reset" 和 "bufsize=4096" 两种格式 */
    if (strncmp(buf, "reset", 5) == 0) {
        spin_lock(&drv_state.lock);
        drv_state.error_count = 0;
        atomic64_set(&drv_state.read_bytes, 0);
        atomic64_set(&drv_state.write_bytes, 0);
        spin_unlock(&drv_state.lock);
        pr_info("mydrv: status reset via /proc\n");
        return count;
    }

    if (sscanf(buf, "bufsize=%lu", &val) == 1) {
        if (val < 64 || val > 1048576) {
            pr_warn("mydrv: invalid bufsize %lu (64-1048576)\n", val);
            return -EINVAL;
        }
        spin_lock(&drv_state.lock);
        drv_state.buffer_size = val;
        spin_unlock(&drv_state.lock);
        pr_info("mydrv: buffer_size set to %lu via /proc\n", val);
        return count;
    }

    pr_warn("mydrv: unknown command: %s\n", buf);
    return -EINVAL;
}

/* 更新 proc_ops，添加 .proc_write */
static const struct proc_ops mydrv_proc_fops = {
    .proc_open    = mydrv_proc_open,
    .proc_read    = seq_read,
    .proc_write   = mydrv_proc_write,
    .proc_lseek   = seq_lseek,
    .proc_release = seq_release,
};

4.6 调试技巧与常见问题

4.7 /proc 与 debugfs、sysfs 的选择

虽然 /proc 是调试利器，但内核社区推荐将 /proc 仅用于进程相关的信息。对于驱动调试，以下三种虚拟文件系统各有侧重：