Linux 内核debugfs总结

最近用到debugfs这个东西,网上找了一堆资料,希望看完这一篇够了。

前言

内核开发者经常需要导出一些信息到用户空间,用于分析内核运行逻辑。最常见的方法是使用 printk(),不过在嵌入式中,printk() 往往直接打印到 console,一旦 printk() 被频繁调用的话,console 就会被刷屏,此时输入命令都是件困难的事情。
有时我们只想偶尔看一下某个内核变量的值,但是一旦使用 printk(),它就会无休止地循环打印;另一方面,使用 printk() 只能打印,而不能从用户空间去修改内核变量的值。为了应对这种情况,我们可以使用 procfs 和 sysfs 这两个虚拟文件系统来实现上述需求。不过通过 procfs 和 sysfs 创建一个文件,来读写某个变量的值,从编码角度看,略微复杂了些。
debugfs

为了让开发人员更轻松地实现调试,内核提供了 debugfs,这是一个致力于调试信息的虚拟文件系统。debugfs 旨在成为一个相对简单和轻量级的子系统。开发人员只需要寥寥几行代码就可以实现调试,并且只需要引用一个头文件 linux/debugfs.h。
示例(调试内核里面一个 u32 类型的变量 count):

debugfs_int.c

#include
#include
#include

static struct dentry *hello_root;
static u32 count;

static int __init hello_init(void)
{
    hello_root = debugfs_create_dir("hello", NULL);
    if (hello_root == NULL) {
        printk("%s: create debugfs dir failed\n", __func__);
        return -1;
    }

    count = 100;
    debugfs_create_u32("count", 0644, hello_root, &count);

    return 0;
}

static void __exit hello_exit(void)
{
    if (hello_root) {
        debugfs_remove_recursive(hello_root);
    }
}

module_init(hello_init);
module_exit(hello_exit);

MODULE_LICENSE("Dual BSD/GPL");

Makefile


KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD       := $(shell pwd)

obj-m    :=debugfs_int.o

all:
    make -C $(KERNELDIR) M=$(PWD) modules

clean:
    rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.* .tmp_versions *.mod *.order *.symvers *.dwo


   

# make && insmod debugfs_int.ko
# cat /sys/kernel/debug/hello/count
100
# echo 30 > /sys/kernel/debug/hello/count
# cat /sys/kernel/debug/hello/count
30

  

使用起来是不是非常方便,除了u32,debugfs 还有很多类型接口

debugfs_create_u8()
debugfs_create_u16()
debugfs_create_u64()
debugfs_create_x8()
debugfs_create_x16()
...
debugfs_create_size_t()
debugfs_create_bool()
...

 

debugfs_create_file()

如果想一次性打印多个变量的值,可以使用 debugfs_create_file(),它可以自定义 read() 函数,我们可以在其中输入多个变量的值。
示例:
debugfs_file.c

#include
#include
#include
#include

static struct dentry *hello_root;

int count_1 = 20;
int count_2 = 30;

static ssize_t hello_read(struct file *filp, char __user *user_buf, size_t count, loff_t *ppos)
{
    char *buf;
    u32 len = 0, size = 4096;
    size_t retval;

    buf = kzalloc(size, GFP_KERNEL);
    if (buf == NULL)
        return -ENOMEM;

    len = scnprintf(buf, size, "count_1: %d\n", count_1);
    len += scnprintf(buf + len, size - len, "count_2: %d\n", count_2);

    retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
    kfree(buf);

    return retval;
}

static ssize_t hello_write(struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
{
    return count;
}

static struct file_operations hello_fops = {
    .owner = THIS_MODULE,
    .read = hello_read,
    .write = hello_write,
};

static int __init hello_init(void)
{
    hello_root = debugfs_create_dir("hello", NULL);
    if (hello_root == NULL) {
        printk("%s: create debugfs dir failed\n", __func__);
        return -1;
    }

    debugfs_create_file("hello_file", S_IWUGO, hello_root, NULL, &hello_fops);

    return 0;
}

static void __exit hello_exit(void)
{
    if (hello_root) {
        debugfs_remove_recursive(hello_root);
    }
}

module_init(hello_init);
module_exit(hello_exit);

MODULE_LICENSE("Dual BSD/GPL");

   
  
 


KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD       := $(shell pwd)

obj-m    :=debugfs_file.o

all:
    make -C $(KERNELDIR) M=$(PWD) modules

clean:
    rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.* .tmp_versions *.mod *.order *.symvers *.dwo

  

# make && insmod debugfs_file.ko
# cat /sys/kernel/debug/hello/hello_file
count_1: 20
count_2: 30
 




背景

我还在读取一个又一个寄存器查gpio配置的时候,大佬,一下清晰明了的搞定了。会的就是多呀。
学习了。
移植完代码,调试设备,一直没办法连接服务器,注册不上,一直停在一个中间状态,查了半天,关键是我这边代码没什么改动呀。回退版本,通过查看git log,应该是中间有人修改了按键和led导致,因为我这边也需要通过复用gpio拉低来控制,改了初始化配置。

但问题不是那么轻易解决的,是一个大神教我我一些调试技术,也就是Debugfs,工作之余,自己拿出来简单学习一下:

时间并不富裕,mark一下,以后有需要再深入学习。
简介

和sysfs_create_file()、sysfs_create_group()类似,通过创建sysfs文件节点,并可以通echo、cat(shell)等来调试。
之前总结过这些,有时间发出来。

Debugfs通过debugfs_create_file创建文件节点。
看使用情况
 

默认情况下,debugfs会被挂载在目录/sys/kernel/debug之下,如果您的发行版里没有自动挂载,可以用如下命令手动完成:

mkdir debug
mount -t debugfs none debug
cat debug/gpio
Linux 内核debugfs总结_第1张图片
GPIO复用情况一目了然。

 

ps:需要root权限。

 



还是知乎者也写得好




linux DebugFS介绍

Debugfs 是内核开发人员向用户空间提供信息的一种简单方法。 /proc 仅用于提供有关进程的信息,或者 sysfs 具有严格的每个文件一个值的规则,而 debugfs 则完全没有规则。开发人员可以将他们想要的任何信息放在那里。 debugfs 文件系统也不能作为用户空间的稳定 ABI;理论上,在那里导出的文件没有稳定性限制。现实世界并不总是那么简单,即使是 debugfs 接口,最好的设计也是考虑到它们需要永远维护。

Debugfs 通常使用如下命令安装:

mount -t debugfs none /sys/kernel/debug

(或等效的 /etc/fstab 行)。默认情况下,只有 root 用户可以访问 debugfs 根目录。要更改对树的访问,可以使用“uid”、“gid”和“mode”挂载选项。

请注意,debugfs API 仅以 GPL 格式导出到模块。

使用 debugfs 的代码应该包括 。然后,首要任务是创建至少一个目录来保存一组 debugfs 文件:

struct dentry *debugfs_create_dir(const char *name, struct dentry *parent);

如果成功,此调用将在指定的父目录下创建一个名为 name 的目录。如果 parent 为 NULL,则将在 debugfs 根目录中创建该目录。成功时,返回值是一个 struct dentry 指针,可用于在目录中创建文件(并在最后清理它)。 ERR_PTR(-ERROR) 返回值表示出现问题。如果返回 ERR_PTR(-ENODEV),这表明内核是在没有 debugfs 支持的情况下构建的,并且下面描述的任何功能都将不起作用。

在 debugfs 目录中创建文件的最常用方法是:

struct dentry *debugfs_create_file(const char *name, umode_t mode,
                                   struct dentry *parent, void *data,
                                   const struct file_operations *fops);

这里,name 是要创建的文件的名称,mode 描述文件应具有的访问权限,parent 表示应保存文件的目录,数据将存储在生成的 inode 结构的 i_private 字段中,fops 是一组实现文件行为的文件操作。至少应该提供 read() 和/或 write() 操作;其他的可以根据需要加入。同样,返回值将是指向已创建文件的 dentry 指针,错误时为 ERR_PTR(-ERROR),如果缺少 debugfs 支持,则返回 ERR_PTR(-ENODEV)。

创建具有初始大小的文件,可以使用以下函数代替:

void debugfs_create_file_size(const char *name, umode_t mode,
                              struct dentry *parent, void *data,
                              const struct file_operations *fops,
                              loff_t file_size);

file_size 是初始文件大小。其他参数与函数 debugfs_create_file 相同。

在许多情况下,实际上并不需要创建一组文件操作。 debugfs 代码为简单的情况提供了许多帮助函数。可以使用以下任何一种创建包含单个整数值的文件:

void debugfs_create_u8(const char *name, umode_t mode,
                       struct dentry *parent, u8 *value);
void debugfs_create_u16(const char *name, umode_t mode,
                        struct dentry *parent, u16 *value);
void debugfs_create_u32(const char *name, umode_t mode,
                        struct dentry *parent, u32 *value);
void debugfs_create_u64(const char *name, umode_t mode,
                        struct dentry *parent, u64 *value)

这些文件支持读取和写入给定值;如果不应写入特定文件,只需相应地设置模式位。这些文件中的值是十进制的;如果十六进制更合适,可以使用以下函数代替:

void debugfs_create_x8(const char *name, umode_t mode,
                       struct dentry *parent, u8 *value);
void debugfs_create_x16(const char *name, umode_t mode,
                        struct dentry *parent, u16 *value);
void debugfs_create_x32(const char *name, umode_t mode,
                        struct dentry *parent, u32 *value);
void debugfs_create_x64(const char *name, umode_t mode,
                        struct dentry *parent, u64 *value);

只要开发人员知道要导出的值的大小,这些函数就很有用。但是,某些类型在不同的架构上可能具有不同的宽度,这使情况有些复杂。在这种特殊情况下,有一些功能可以提供帮助:

void debugfs_create_size_t(const char *name, umode_t mode,
                           struct dentry *parent, size_t *value);

正如所料,此函数将创建一个 debugfs 文件来表示 size_t 类型的变量。

同样,对于 unsigned long 类型的变量,有十进制和十六进制的助手:

struct dentry *debugfs_create_ulong(const char *name, umode_t mode,
                                    struct dentry *parent,
                                    unsigned long *value);
void debugfs_create_xul(const char *name, umode_t mode,
                        struct dentry *parent, unsigned long *value);

布尔值可以放在 debugfs 中:

void debugfs_create_bool(const char *name, umode_t mode,
                         struct dentry *parent, bool *value);

对结果文件的读取将产生 Y(对于非零值)或 N,后跟换行符。如果写入,它将接受大写或小写值,或者 1 或 0。任何其他输入都将被忽略。

此外, atomic_t 值可以放在 debugfs 中:

void debugfs_create_atomic_t(const char *name, umode_t mode,
                             struct dentry *parent, atomic_t *value)

读取此文件将获得 atomic_t 值,写入此文件将设置 atomic_t 值。 另一种选择是导出具有以下结构和功能的任意二进制数据块:

struct debugfs_blob_wrapper {
    void *data;
    unsigned long size;
};

struct dentry *debugfs_create_blob(const char *name, umode_t mode,
                                   struct dentry *parent,
                                   struct debugfs_blob_wrapper *blob);

读取此文件将返回 debugfs_blob_wrapper 结构指向的数据。一些驱动程序使用“blob”作为返回多行(静态)格式化文本输出的简单方法。此函数可用于导出二进制信息,但在主线中似乎没有任何代码这样做。请注意,使用 debugfs_create_blob() 创建的所有文件都是只读的。

如果你想转储一个寄存器块(在开发过程中经常发生的事情,即使很少有这样的代码到达主线。Debugfs 提供两个功能:一个是创建一个仅寄存器文件,另一个是在中间插入一个寄存器块另一个顺序文件:

struct debugfs_reg32 {
    char *name;
    unsigned long offset;
};

struct debugfs_regset32 {
    const struct debugfs_reg32 *regs;
    int nregs;
    void __iomem *base;
    struct device *dev;     /* Optional device for Runtime PM */
};

debugfs_create_regset32(const char *name, umode_t mode,
                        struct dentry *parent,
                        struct debugfs_regset32 *regset);

void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
                     int nregs, void __iomem *base, char *prefix);

“base”参数可能为 0,但您可能希望使用 __stringify 构建 reg32 数组,并且许多寄存器名称(宏)实际上是寄存器块基数上的字节偏移量。

如果要在 debugfs 中转储 u32 数组,可以使用以下命令创建文件:

struct debugfs_u32_array {
    u32 *array;
    u32 n_elements;
};

void debugfs_create_u32_array(const char *name, umode_t mode,
                    struct dentry *parent,
                    struct debugfs_u32_array *array);

“array”参数包含一个指向数组数据及其元素数量的指针。注意:一旦创建数组,它的大小就不能改变。

有一个辅助函数来创建设备相关的 seq_file:

void debugfs_create_devm_seqfile(struct device *dev,
                             const char *name,
                             struct dentry *parent,
                             int (*read_fn)(struct seq_file *s,
                                     void *data));

“dev”参数是与这个debugfs文件相关的设备,“read_fn”是一个函数指针,被调用来打印seq_file的内容。

还有其他几个面向目录的帮助函数:

struct dentry *debugfs_rename(struct dentry *old_dir,
                              struct dentry *old_dentry,
                              struct dentry *new_dir,
                              const char *new_name);

struct dentry *debugfs_create_symlink(const char *name,
                                      struct dentry *parent,
                                      const char *target);

调用 debugfs_rename() 将为现有的 debugfs 文件提供一个新名称,可能位于不同的目录中。 new_name 在调用之前不能存在;返回值是带有更新信息的 old_dentry。可以使用 debugfs_create_symlink() 创建符号链接。

所有 debugfs 用户都必须考虑一件重要的事情:不会自动清理在 debugfs 中创建的任何目录。如果一个模块在没有明确删除 debugfs 条目的情况下被卸载,结果将是很多过时的指针,并且没有结束高度反社会的行为。因此,所有 debugfs 用户——至少是那些可以构建为模块的用户——必须准备好删除他们在那里创建的所有文件和目录。可以通过以下方式删除文件:

void debugfs_remove(struct dentry *dentry);

dentry 值可以是 NULL 或错误值,在这种情况下不会删除任何内容。

曾几何时,debugfs 用户需要记住他们创建的每个 debugfs 文件的 dentry 指针,以便清理所有文件。不过,我们现在生活在更加文明的时代,debugfs 用户可以调用

void debugfs_remove_recursive(struct dentry *dentry);

如果这个函数被传递了一个指向顶层目录对应的dentry的指针,那么该目录下的整个层次结构将被删除。

翻译自:

The Linux Kernel documentation

 







Linux内核空间-用户空间通信之debugfs

一、debugfs文件系统简介

debugfs虚拟文件系统是一种内核空间与用户空间的接口,基于libfs库实现,专用于开发人员调试,便于向用户空间导出内核空间数据(当然,反方向也可以)。debugfs在linux内核版本2.6.10引入,作者是Greg Kroah-Hartman。

与procfs和sysfs不同,前者主要提供进程信息(当然后来又加入设备、内存、网络等信息,比较杂乱),后者主要提供设备信息,且有一个文件提供一个值的“规则”,是Linux通用设备模型的影射。debugfs没有类似的限制,开发者可以放入任何信息。

二、debugfs的使用

说明:函数接口请参见:Linux Kernel: fs/debugfs/file.c File Reference

1. 挂载debugfs文件系统

要使用debugfs,需要在内核编译配置中配置CONFIG_DEBUG_FS选项,一般的发行版都会默认编译进了内核,并且将其自动挂载默认的目录(/sys/kernel/debug),可通过以下命令查看:

 

也可手动挂载到其它位置:

$ mkdir /debugfs
$ mount -t debugfs none /debugfs

2. 利用debugfs导出基本数据类型的变量

debugfs可以将内核中基本整数类型的变量导出为单个文件,在用户空间中可以直接对其读写(如使用cat、echo命令),只要权限允许即可。支持的类型有:u8, u16, u32, u64, size_t和 bool。其中bool类型在内核中要定义为u32类型,在用户空间中对应的文件内容则显示为Y或N。示例代码如下:

static struct dentry *root_d = debugfs_create_dir("exam_debugfs", NULL); //在debugfs根目录下创建新目录exam_debugfs,然会新建目录的目录项指针
static u8 var8;
debugfs_create_u8("var-u8", 0664, root_d, &var8); //在exam_debugfs中创建变量var8对应的文件,名为var-u8,权限为0664
static u32 varbool;
debugfs_create_bool("var-bool", 0664, root_d, &varbool); //bool变量

3. 利用debugfs导出数据块(只读)

debugfs提供的debugfs_create_blob函数可导出数据块,示例代码如下:

char buf[] = "Hello debugfs!
";
b.data = buf;
b.size = strlen(buf) + 1;
debugfs_create_blob("blob", 0644, root_d, &b); // blob is readonly, even if 0644

没错,debugfs提供的debugfs_blob_wrapper结构所导出的数据块只能读取,不能修改。

4. 利用debugfs导出u32数组(只读)

debugfs提供的debugfs_create_u32_array函数可导出内核中u32类型的数组。示例代码如下:

u32 arr[] = {1,2,3,4,5};
debugfs_create_u32_array("array", 0664, root_d, arr, sizeof(arr)/sizeof(u32));

5. 实现可读写数据块的导出

实现并不难,只需实现struct file_operations的open、write、read方法即可。然后调用debugfs提供的debugfs_create_file即可。该方法的原型如下:

struct dentry* debugfs_create_file	(	const char * 	name,
	umode_t 	mode,
	struct dentry * 	parent,
	void * 	data, // 传入的data指针会被赋值给新建文件对应inode的i_private字段
	const struct file_operations * 	fops 
)	

下面,仿照struct debugfs_blob_wrapper的实现,实现struct my_blob_wrapper和my_blob_wrapper_ops,提供可读写的“blob”:

/** 自定义可读写blob **/
struct my_blob_wrapper{
    void *data;
    unsigned long size; // data缓冲区长度
};
static int my_blob_wrapper_open(struct inode *inode, struct file *filp)
{
    filp->private_data = inode->i_private; // inode->i_private被设置为debugfs_create_file传入的data参数
    return 0;
}
static ssize_t my_blob_wrapper_read(struct file *filp, char __user *user_buf, size_t count, loff_t *ppos)
{
    struct my_blob_wrapper *blob = filp->private_data;
    return simple_read_from_buffer(user_buf, count, ppos,
            blob->data, blob->size);//此函数有libfs提供,与下面逻辑等价
//    if (*ppos >= blob->size) {
//        return 0;
//    }
//    if (*ppos + count > blob->size) {
//        count = blob->size - *ppos;
//    }
//    if (copy_to_user(user_buf, blob->data + *ppos, count) != 0) {
//        return -EFAULT;
//    }
//    *ppos += count;
//    return count;
}
static ssize_t my_blob_wrapper_write(struct file *filp, const char __user *user_buf, size_t count, loff_t *ppos)
{
    struct my_blob_wrapper *blob = filp->private_data;
    return simple_write_to_buffer(blob->data, blob->size, ppos,
                    user_buf, count);//此函数由libfs提供,与下面逻辑等价
//    if (*ppos >= blob->size) {
//        return 0;
//    }
//    if (*ppos + count > blob->size) {
//        count = blob->size - *ppos;
//    }
//    if (copy_from_user(blob->data + *ppos, user_buf, count) != 0) {
//        return -EFAULT;
//    }
//    *ppos += count;
//    return count;
}
static struct file_operations my_blob_wrapper_ops = {
    .owner = THIS_MODULE,
    .open = my_blob_wrapper_open,
    .read = my_blob_wrapper_read,
    .write = my_blob_wrapper_write,
    .llseek = default_llseek,//VFS提供
};
struct dentry *my_create_blob(const char *name, umode_t mode,
          struct dentry *parent,
          struct my_blob_wrapper *blob)
{
    return debugfs_create_file(name, mode, parent, blob, &my_blob_wrapper_ops);
}
/* done */

6. 注意:

① 在debugfs中创建的文件和目录在模块退出时,并不会自动删除,可调用debugfs_remove_recursive删除整个目录,或调用debugfs_remove删除单个文件。

② u32_array在用户空间文件中显示为空格隔开的元素

③ debugfs_create_x{8,16,32,64}与debugfs_create_u{8,16,32,64}的不同在于前者显示为16进制,后者显示为10进制

三、debugfs示例完整代码

#include 
#include 
#include  // for libfs
#include 

/** 自定义可读写blob **/
struct my_blob_wrapper{
    void *data;
    unsigned long size;
};
static int my_blob_wrapper_open(struct inode *inode, struct file *filp)
{
    filp->private_data = inode->i_private;
    return 0;
}
static ssize_t my_blob_wrapper_read(struct file *filp, char __user *user_buf, size_t count, loff_t *ppos)
{
    struct my_blob_wrapper *blob = filp->private_data;
    return simple_read_from_buffer(user_buf, count, ppos, 
            blob->data, blob->size); // from libfs
}
static ssize_t my_blob_wrapper_write(struct file *filp, const char __user *user_buf, size_t count, loff_t *ppos)
{
    struct my_blob_wrapper *blob = filp->private_data;
    return simple_write_to_buffer(blob->data, blob->size, ppos, 
                    user_buf, count);
}
static struct file_operations my_blob_wrapper_ops = {
    .owner = THIS_MODULE,
    .open = my_blob_wrapper_open,
    .read = my_blob_wrapper_read,
    .write = my_blob_wrapper_write,
    .llseek = default_llseek, // from vfs
};
/* 接口函数 */
struct dentry *my_create_blob(const char *name, umode_t mode,
          struct dentry *parent,
          struct my_blob_wrapper *blob)
{
    return debugfs_create_file(name, mode, parent, blob, &my_blob_wrapper_ops);
}
/** my_clob implementation end **/

static struct dentry *root_d;
static u8 var8;
static u16 var16;
static u32 var32;
static u32 varbool;
static char buf[] = "Hello debugfs!
";
static struct debugfs_blob_wrapper b;
static struct my_blob_wrapper b2;
static u32 arr[] = {1,2,3,4,5};

int __init mod_init(void)
{
    printk(KERN_INFO "exam_debugfs: initialing...
");
    root_d = debugfs_create_dir("exam_debugfs", NULL);
    if (!root_d) {
        printk(KERN_INFO "exam_debugfs: error create root dir
");
        return 1;
    }
    /* u{8,16,32}, bool */
    debugfs_create_u8("var-u8", 0664, root_d, &var8);
    debugfs_create_u16("var-u16", 0664, root_d, &var16);
    debugfs_create_u32("var-u32", 0664, root_d, &var32);
    debugfs_create_bool("var-bool", 0664, root_d, &varbool);
    /* u32_array */
    debugfs_create_u32_array("array", 0664, root_d, arr, sizeof(arr)/sizeof(u32));
    /* blob_wrapper */
    b.data = buf;
    b.size = strlen(buf) + 1;
    debugfs_create_blob("blob", 0644, root_d, &b); // blob is readonly, even if 0644
    /* my_blob_wrapper */
    b2.data = buf;
    b2.size = strlen(buf) + 1;
    my_create_blob("myblob", 0644, root_d, &b2);

    return 0;
}
void __exit mod_exit(void)
{
    debugfs_remove_recursive(root_d);
    printk(KERN_INFO "exam_debugfs: exiting...
");
}


module_init(mod_init);
module_exit(mod_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("a demo for debugfs");
MODULE_AUTHOR("rsljdkt");

四、补充:debugfs bool的实现

static ssize_t read_file_bool(struct file *file, char __user *user_buf,
                  size_t count, loff_t *ppos)
{
    char buf[3];
    u32 *val = file->private_data;
    
    if (*val)
        buf[0] = 'Y';
    else
        buf[0] = 'N';
    buf[1] = '
';
    buf[2] = 0x00;
    return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
}

static ssize_t write_file_bool(struct file *file, const char __user *user_buf,
                   size_t count, loff_t *ppos)
{
    char buf[32];
    size_t buf_size;
    bool bv;
    u32 *val = file->private_data;

    buf_size = min(count, (sizeof(buf)-1));
    if (copy_from_user(buf, user_buf, buf_size))
        return -EFAULT;

    if (strtobool(buf, &bv) == 0)
        *val = bv;

    return count;
}

你可能感兴趣的:(Linux内核驱动,linux,驱动开发)