Linux内核编程(08)：debugfs文件系统

最新推荐文章于 2023-09-25 17:06:46 发布
最新推荐文章于 2023-09-25 17:06:46 发布
阅读量1.6k 收藏 19
点赞数 5
分类专栏： Linux 内核编程学习记录 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29023095/article/details/123164897
版权

一、什么是debugfs

简介：天生为调试内核而生，一个基于内存的文件系统，基于libfs开发的，提供的调试功能强大；相对于procfs、sysfs的优势：

​ procfs：使用procfs调试内核、修改寄存器，对于他的底层read、write接口添加了大量的调试代码。

​ sysfs：设备模型，导出到用户空间。

​ debugfs：简化了导处的接口，一行代码就可以将内核变量、数组、链表、内存中的数据、寄存器等信息进行导出。挂载在/sys/kernel/debug上。

二、debugfs配置编译和注册运行

​ linux-5.10：vexpress_defconfig

​ make vexpress_defconfig；NFS v4.x; make uImage; make all(用于生成Module.symvers文件，该文件在编译独立模块时会用到，有些正常编译时就会产生该文件，如果没有的话，我们再使用make all进行编译);

​ 内核中的很多模块，都用到了debugfs的API接口，CONFIG_DEBUG_FS，如果没有配置则对应的为空函数。

// /fs/debugfs/inode.c
early_param("debugfs", debugfs_kernel);
static int __init debugfs_init(void)
{
    int retval;

    if (!(debugfs_allow & DEBUGFS_ALLOW_MOUNT))
        return -EPERM;

    retval = sysfs_create_mount_point(kernel_kobj, "debug");
    if (retval)
        return retval;

    retval = register_filesystem(&debug_fs_type);
    if (retval)
        sysfs_remove_mount_point(kernel_kobj, "debug");
    else
        debugfs_registered = true;

    return retval;
}

三、第一个debugfs编程示例

​ 使用debugfs提供的API接口在debugfs目录下生成自己的文件或者目录。相关的API定义在include/linux/debugfs.h目录下。

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/debugfs.h>

static unsigned int hello_value;
static struct dentry *hello_root;

static int __init hello_debugfs_init(void)
{
    // 创建目录hello
    hello_root = debugfs_crate_dir("hello", NULL);
    if (IS_ERR(hello_root)) {
        pr_err("%s: create debugfs dir failed.\n", __func__);
        return PTR_ERR(hello_root);
    }
     // 创建变量hello_reg
    debugfs_create_u32("hello_reg", 0644, hello_root, &hello_value);
	
    return 0;
}

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

module_init(hello_debugfs_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");

四、通过debugfs导出整形数据

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/debugfs.h>

static unsigned int hello_value;
static struct dentry *hello_root;

static u8 u8_a;
static u16 u16_a;
static size_t size_t_a;
static unsigned long ulong_a;
static bool bool_a;

static int __init hello_debugfs_init(void)
{
    hello_root = debugfs_create_dir("hello", NULL);
    if (IS_ERR(hello_root)) {
        pr_error("%s: create debugfs dir failed\n", __func__);
        return PTR_ERR(hello_root);
    }
    
    debugfs_create_u32("hello_reg", 0644, hello_root, &hello_value);
    debugfs_create_u8("u8_reg", 0644, hello_root, &u8_a);
    debugfs_create_u16("u16_reg", 0644, hello_root, &u16_a);
    debugfs_create_u64("u64_reg", 0644, hello_root, &u64_a);
    debugfs_create_size_t("size_t_reg", 0644, hello_root, &size_t_a);
    debugfs_create_ulong("ulong_reg", 0644, hello_root, &ulong_a);
    debugfs_create_bool("bool_reg", 0644, hello_root, &bool_a);
}

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

module_init(hello_debugfs_init);
module_exit(hello_debugfs_exit);

五、通过debugfs导出16进制数据

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/debugfs.h>

static unsigned int hello_value;
static struct dentry *hello_root;

static u8 u8_a;
static u16 u16_a;
static u64 u64_a;


static int __init hello_debugfs_init(void)
{
    hello_root = debugfs_create_dir("hello", NULL);
    if (IS_ERR(hello_root)) {
        pr_error("%s: create debugfs dir failed\n", __func__);
        return PTR_ERR(hello_root);
    }
    
    // 带有x的函数在显示时，以16进制进行显示.
    debugfs_create_x32("hello_reg", 0644, hello_root, &hello_value);
    debugfs_create_x8("u8_reg", 0644, hello_root, &u8_a);
    debugfs_create_x16("u16_reg", 0644, hello_root, &u16_a);
    debugfs_create_x64("u64_reg", 0644, hello_root, &u64_a);
}

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

module_init(hello_debugfs_init);
module_exit(hello_debugfs_exit);

六、通过debugfs导出数组

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/debugfs.h>

static struct dentry *hello_root;
static u32 hello_array[8] = {1, 2, 3, 4, 5, 6, 7, 8};

static struct debugfs_u32_array array_info = {
    .array = hello_array,
    .n_elements = 8,
};

static int __init hello_debugfs_init(void)
{
    int ret = 0;

    hello_root = debugfs_create_dir("hello", NULL);
    if (IS_ERR(hello_root)) {
        pr_error("%s: create debugfs dir failed\n", __func__);
        return PTR_ERR(hello_root);
    }
    
    // 通过debugfs_create_u32_array函数导出数组，读起来比较方便；写的时候相对不太行.
    debugfs_create_u32_array("hello_array", S_IWUGO, hello_root, &array_info);
   
    return ret;
}

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

module_init(hello_debugfs_init);
module_exit(hello_debugfs_exit);

七、通过debugfs导出内存数据

​ 任意一块内存，通过地址都可将数据导出.

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/debugfs.h>

static struct dentry *hello_root;
static u32 hello_array[8] = {1, 2, 3, 4, 5, 6, 7, 8};
static char *mem_block_p = NULL;

static struct debugfs_u32_array array_info = {
    .array = hello_array,
    .n_elements = 8,
};

static struct debugfs_blob_wrapper hello_blob = {
    .data = hello_array,
    .size = 8 * sizeof(u32),
};

static struct debugfs_blob_wrapper hello_mem;

static int __init hello_debugfs_init(void)
{
    int ret = 0;
    
    mem_block_p = kmalloc(32, GFP_ATOMIC);
	if (!mem_block_p) {
        pr_err("%s: kmalloc memory failed\n", __func__);
        return -ENOMEM;
    }
    memcpy(mem_block_p, "hello zhaixue.cc\n", 20);
    hello_mem.data = mem_block_p;
    hello_mem.size = 32;
    hello_root = debugfs_create_dir("hello", NULL);
    if (IS_ERR(hello_root)) {
        pr_error("%s: create debugfs dir failed\n", __func__);
        return PTR_ERR(hello_root);
    }
    
    // 通过debugfs_create_u32_array函数导出数组，读起来比较方便；写的时候相对不太行.
    debugfs_create_u32_array("hello_array", S_IWUGO, hello_root, &array_info);
   	debugfs_create_blob("hello_blob", S_IWUGO, hello_root, &hello_blob);
    debugfs_create_blob("hello_mem", S_IWUGO, hello_root, &hello_mem);
    return ret;
}

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

module_init(hello_debugfs_init);
module_exit(hello_debugfs_exit);

八、通过debugfs导出自定义格式数据

​ 自己构建适合我们格式的读写file_operation接口，来完成实现数据的读写。

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/debugfs.h>

static struct dentry *hello_root;
static unsigned int hello_value;
static char hello_buf[100];

static size_t hello_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
{
    int ret;
    if (*ppos >= 100) {
        return 0;
    }
    if (*ppos + count > 100) {
        count = 100 - *ppos;
    }
    
    ret = copy_to_user(buf, hello_buf, count);
    if (ret) {
        return -EFAULT;
    }
    *ppos += count;
    
    return count;
}

static void hello_write(struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
{
    int ret;
    if (*ppos >= 100) {
        return 0;
    }
    if (*ppos + count > 100) {
        count = 100 - *ppos;
    }
    
    ret = copy_from_user(hello_buf, buf, count);
    if (ret) {
        return -EFAULT;
    }
    *ppos += count;
    
    return count;
}

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

static int __init hello_debugfs_init(void)
{
    int ret = 0;
    
    mem_block_p = kmalloc(32, GFP_ATOMIC);
	if (!mem_block_p) {
        pr_err("%s: kmalloc memory failed\n", __func__);
        return -ENOMEM;
    }
	
    debugfs_create_x32("hello_reg", 0644, hello_root, &hello_value);
    debugfs_create_file("hello_buffer", S_IWUGO, hello_root, NULL, &hello_fops);
   
    return ret;
}

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

module_init(hello_debugfs_init);
module_exit(hello_debugfs_exit);

九、在debugfs使用seq_file接口

​ debugfs + seq_file接口配合使用

​ seq_read, seq_opertions: start/next/show/stop, show函数自己实现

​ seq_read, seq_opertions: 自己实现seq_operation的接口.

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>

static struct dentry *hello_root;
static char hello_buf[100];

static int hello_debugfs_show(struct seq_file *s, void *data)
{
    char *p = s->private;
    seq_printf(s, "%s", p);
    
    return 0;
}

static int hello_open(struct inode *inode, struct file *filp)
{
    return single_open(file, hello_debugfs_show, inode->i_private);
}

static size_t hello_write(struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
{
     int ret;
    if (*ppos >= 100) {
        return 0;
    }
    if (*ppos + count > 100) {
        count = 100 - *ppos;
    }
    
    ret = copy_from_user(hello_buf, buf, count);
    if (ret) {
        return -EFAULT;
    }
    *ppos += count;
    
    return count;
}

struct file_operations hello_fops = {
    .owner   = THIS_MODULE,
    .open    = hello_open,
    .read    = seq_read,
    .write   = hello_write,
    .llseek  = seq_lseek,
    .release = single_release,
};

static int __init hello_debugfs_init(void)
{
    hello_root = debugfs_create_dir("hello", NULL);
    if (IS_ERR(hello_root)) {
        pr_err("");
        return PTR_ERR(hello_root);
    }

    debugfs_create_file("hello_buffer", S_IWUGO, hello_root, hello_buf, &hello_fops);
   
    return ret;
}

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

module_init(hello_debugfs_init);
module_exit(hello_exit);

十、使用seq_file接口遍历数组

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>

struct hello_struct {
    unsigned int value;
    unsigned int id;
};

static struct dentry *hello_root;
static struct hello_struct hello_array[8];
static char hello_buf[64];
static int index = 0;

static void *hello_seq_start(struct seq_file *s, loff_t *pos)
{
    printk("----------start: *pos = %lld\n", *pos);
    if (*pos == 0){
        return &hello_array[0];
    }
    else {
        *pos = 0;
        return NULL;
    }
}

static void *hello_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
    struct hello_struct  *p_node = NULL;
    (*pos)++;
    printk("---------next: *pos = %lld\n", *pos);
    p_node = &hello_array[*pos];
    
    if (*pos == 8) {
    //    *pos = 0;
        return NULL;
    }
    return p_node;
}

static void hello_seq_stop(struct seq_file *s, void *v)
{
    printk("stop\n");
}

static int hello_seq_show(struct seq_file *s, void *v)
{
    struct hello_struct *p = (struct hello_struct *)v;
    printk("---------show: id = %d\n", p->id);
    if (p->id > 0)
        seq_printf(s, "hello_arr[%d].value = 0x%x\n", p->id-1, \
                      hello_array[p->id-1].value);
    return 0;
}

static struct seq_operations hello_seq_ops = {
    .start = hello_seq_start,
    .next  = hello_seq_next,
    .stop  = hello_seq_stop,
    .show  = hello_seq_show,
};

static int hello_open(struct inode *inode, struct file *file)
{
    return seq_open(file, &hello_seq_ops);
}

static ssize_t hello_write(struct file *filp, const char __user *buf, 
                            size_t len, loff_t *ppos)
{
    int ret;
    if (len == 0 || len > 64) {
        ret = -EFAULT;
        return ret;
    }
    ret = copy_from_user(hello_buf, buf, len);
    if (ret)
        return -EFAULT;
    printk("hello_write: index = %d\n", index);
    hello_array[index].id = index + 1;
    hello_array[index].value = simple_strtoul(hello_buf, NULL, 0);
    index++;
    if (index == 8)
        index = 0;
    return len;
}

static const struct file_operations hello_ops = {
    .owner    = THIS_MODULE,
    .open     = hello_open,
    .read     = seq_read,
    .write    = hello_write,
    .llseek    = seq_lseek,
};



static int __init hello_debugfs_init(void)
{
    int ret = 0;

    hello_root = debugfs_create_dir("hello", NULL);
    if (IS_ERR(hello_root)) {
        pr_err("%s: create debugfs dir failed\n", __func__);
        return PTR_ERR(hello_root);
    }

    debugfs_create_file("hello_buffer", S_IWUGO, hello_root,  , 
                        &hello_ops);

    return ret;
}

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

module_init(hello_debugfs_init);
module_exit(hello_debugfs_exit);

十一、使用seq_file接口遍历链表

通过实现自定义的seq_operations接口，以及seq_file的链表接口.

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/slab.h>

static struct dentry *hello_root;

static char hello_buf[64];
static struct list_head hello_list_head;

struct hello_struct {
    unsigned int value;
    struct list_head node;
};


static void *hello_seq_start(struct seq_file *s, loff_t *pos)
{
   return seq_list_start(&hello_list_head, *pos) ;
}

static void *hello_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
    return seq_list_next(v, &hello_list_head, pos);
}

static void hello_seq_stop(struct seq_file *s, void *v)
{
    //printk("stop\n");
}

static int hello_seq_show(struct seq_file *s, void *v)
{
    struct hello_struct *p_node = list_entry(v, struct hello_struct, node);
    seq_printf(s, "node = 0x%x\n",  p_node->value);
    return 0;
}

static struct seq_operations hello_seq_ops = {
    .start = hello_seq_start,
    .next  = hello_seq_next,
    .stop  = hello_seq_stop,
    .show  = hello_seq_show,
};

static int hello_open(struct inode *inode, struct file *file)
{
    return seq_open(file, &hello_seq_ops);
}

static ssize_t hello_write(struct file *filp, const char __user *buf, 
                            size_t len, loff_t *ppos)
{
    int ret;
    struct hello_struct *data;
    if (len == 0 || len > 64) {
        ret = -EFAULT;
        return ret;
    }
    ret = copy_from_user(hello_buf, buf, len);
    if (ret)
        return -EFAULT;

    data = kmalloc(sizeof(struct hello_struct), GFP_KERNEL);
    if (data != NULL) {
        data->value = simple_strtoul(hello_buf, NULL, 0);
        list_add(&data->node, &hello_list_head);
    }

    return len;
}

static const struct file_operations hello_ops = {
    .open   = hello_open,
    .read   = seq_read,
    .write  = hello_write,
    .llseek = seq_lseek,
};

static int __init hello_debugfs_init(void)
{
    int ret = 0;
    
    INIT_LIST_HEAD(&hello_list_head);

    hello_root = debugfs_create_dir("hello", NULL);
    if (IS_ERR(hello_root)) {
        pr_err("%s: create debugfs dir failed\n", __func__);
        return PTR_ERR(hello_root);
    }

    debugfs_create_file("hello_list", S_IWUGO, hello_root, NULL, &hello_ops);

    return ret;
}

static void __exit hello_debugfs_exit(void)
{
    struct hello_struct *data;
    
    if (hello_root)
        debugfs_remove_recursive(hello_root);

    while (!list_empty(&hello_list_head)) {
        data = list_entry(hello_list_head.next, struct hello_struct, node);
        list_del(&data->node);
        kfree(data);
    }

}

module_init(hello_debugfs_init);
module_exit(hello_debugfs_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("wit@zhaixue.cc");

十二、使用debugfs导出寄存器的列表

此案例中，寄存器为只读属性。

#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/debugfs.h>

typedef volatile struct {
        unsigned long  RTCDR;    /* +0x00: data register */
        unsigned long  RTCMR;    /* +0x04: match register */
        unsigned long  RTCLR;    /* +0x08: load register */
        unsigned long  RTCCR;    /* +0x0C: control register */
        unsigned long  RTCIMSC;  /* +0x10: interrupt mask set and clear register*/
        unsigned long  RTCRIS;   /* +0x14: raw interrupt status register*/
        unsigned long  RTCMIS;   /* +0x18: masked interrupt status register */
        unsigned long  RTCICR;   /* +0x1C: interrupt clear register */
}rtc_reg_t;

struct rtc_time {
    unsigned int year;
    unsigned int mon;
    unsigned int day;
    unsigned int hour;
    unsigned int min;
    unsigned int sec;
};

#define RTC_BASE 0x10017000

static volatile rtc_reg_t *regs = NULL;
static unsigned long cur_time = 0;
static struct rtc_time tm;

static dev_t devno;
static struct cdev *rtc_cdev;

static void rtc_time_translate(void)
{
    tm.hour = (cur_time  % 86400) / 3600;
    tm.min  = (cur_time  % 3600) / 60;
    tm.sec  = cur_time  % 60;
}

static void set_rtc_alarm(void)
{
    unsigned long tmp = 0;
    
    tmp = regs->RTCCR;
    tmp = tmp & 0xFFFFFFFE;
    regs->RTCCR = tmp;


    cur_time = regs->RTCDR;
    regs->RTCMR = cur_time + 15;

    regs->RTCICR = 0x1;
    regs->RTCIMSC = 0x1;

    tmp = regs->RTCCR;
    tmp = tmp | 0x1;
    regs->RTCCR = tmp;
}

static irqreturn_t rtc_alarm_handler(int irq, void *dev_id)
{

    cur_time = regs->RTCDR;
    rtc_time_translate();
    printk("\nalarm: beep~ beep~ \n");
    printk("\n    %d:%d:%d\n", tm.hour, tm.min, tm.sec);
    regs->RTCICR = 1;
    set_rtc_alarm();
    return IRQ_HANDLED;
}

static struct file_operations rtc_fops;

static const struct debugfs_reg32 rtc_reg_array[] = {
    {
        .name   = "RTCDR",
        .offset = 0x0
    },
    {
        .name   = "RTCMR",
        .offset = 0x4
    },
    {
        .name   = "RTCLR",
        .offset = 0x8
    },
    {
        .name   = "RTCCR",
        .offset = 0xC
    },
    {
        .name   = "RTCIMSC",
        .offset = 0x10
    },
    {
        .name   = "RTCRIS",
        .offset = 0x14
    },
    {
        .name   = "RTCMIS",
        .offset = 0x18
    },
    {
        .name   = "RTCICR",
        .offset = 0x1C
    }
};

static struct debugfs_regset32 rtc_regset;
static struct dentry *hello_root;

static int __init rtc_init(void)
{
    int ret = 0;
    
    regs = (rtc_reg_t *)ioremap(RTC_BASE, sizeof(rtc_reg_t));

    ret = alloc_chrdev_region(&devno, 0, 1, "rtc-demo");
    if (ret) {
        printk("alloc char device number failed!\n");
        return ret;
    }
    printk("RTC devnum:%d minornum:%d\n", MAJOR(devno), MINOR(devno));

    rtc_cdev = cdev_alloc();
    cdev_init(rtc_cdev, &rtc_fops);

    ret = cdev_add(rtc_cdev, devno, 1);
    if (ret < 0) {
        printk("cdev_add failed..\n");
        return -1;
    }
    else {
        printk("Register char module: rtc success!\n");
    }

    ret = request_irq(39, rtc_alarm_handler, 0, "rtc-test", NULL);
    if (ret == -1) {
        printk("request_irq failed!\n");
        return -1;
    }

    set_rtc_alarm();

    hello_root = debugfs_create_dir("hello", NULL);
    if (IS_ERR(hello_root)) {
        pr_err("%s: create rtc dir failed\n", __func__);
        return PTR_ERR(hello_root);
    }

    rtc_regset.regs  = rtc_reg_array;
    rtc_regset.nregs = 8;
    rtc_regset.base  = (void *)regs;
    // 注意debugfs_create_regset32函数最后一个参数为寄存器相关的结构体
    debugfs_create_regset32("reglist", 0644, hello_root, &rtc_regset);

    return 0;
}

static void __exit rtc_exit(void)
{
    if (hello_root)
        debugfs_remove_recursive(hello_root);

    free_irq(39, NULL);
    cdev_del(rtc_cdev);
    unregister_chrdev_region(devno, 1);
}

module_init(rtc_init);
module_exit(rtc_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("wit@zhaixue.cc");

十三、使用debugfs修改寄存器

#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/module.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/interrupt.h>

typedef volatile struct {
        unsigned int  RTCDR;    /* +0x00: data register */
        unsigned int  RTCMR;    /* +0x04: match register */
        unsigned int  RTCLR;    /* +0x08: load register */
        unsigned int  RTCCR;    /* +0x0C: control register */
        unsigned int  RTCIMSC;  /* +0x10: interrupt mask set and clear register*/
        unsigned int  RTCRIS;   /* +0x14: raw interrupt status register*/
        unsigned int  RTCMIS;   /* +0x18: masked interrupt status register */
        unsigned int  RTCICR;   /* +0x1C: interrupt clear register */
}rtc_reg_t;

struct rtc_time {
    unsigned int year;
    unsigned int mon;
    unsigned int day;
    unsigned int hour;
    unsigned int min;
    unsigned int sec;
};

#define RTC_BASE 0x10017000

static volatile rtc_reg_t *regs = NULL;
static unsigned long cur_time = 0;
static struct rtc_time tm;

static void rtc_time_translate(void)
{
    tm.hour = (cur_time % 86400) / 3600;
    tm.min  = (cur_time % 3600) / 60;
    tm.sec = cur_time % 60;
}

static void rtc_tm_to_time(void)
{
    cur_time = tm.hour * 3600 + tm.min * 60 + tm.sec;
}


static dev_t devno;
static struct cdev *rtc_cdev;

static int rtc_open(struct inode *inode, struct file *fp)
{
    return 0;
}

static int rtc_release(struct inode *inode, struct file *fp)
{
    return 0;
}

static ssize_t rtc_read(struct file *fp, char __user *buf, 
                           size_t size, loff_t *pos)
{

    cur_time = regs->RTCDR;
    rtc_time_translate();
    if (copy_to_user(buf, &tm, sizeof(struct rtc_time)) != 0){
        printk("rtc_read error!\n");
        return -1;
    }

    return sizeof(struct rtc_time);
}

static ssize_t rtc_write(struct file *fp, const char __user *buf, 
                            size_t size, loff_t *pos)
{
    int len = 0;
    
    len = sizeof(struct rtc_time);
    if (copy_from_user(&tm, buf, len) != 0) {
        printk("rtc_write error!\n");
        return -1;
    }
    rtc_tm_to_time();
    regs->RTCLR = cur_time;

    return len;
}

/* standard file I/O system call interface */
static const struct file_operations rtc_fops = {
    .owner   = THIS_MODULE,
    .read    = rtc_read,
    .write   = rtc_write,
    .open    = rtc_open,
    .release = rtc_release,
};

static void set_rtc_alarm(void)
{
    unsigned int tmp = 0;
    
    tmp = regs->RTCCR;
    tmp = tmp & 0xFFFFFFFE;
    regs->RTCCR = tmp;


    cur_time = regs->RTCDR;
    regs->RTCMR = cur_time + 25;

    regs->RTCICR = 1;
    regs->RTCIMSC = 1;

    tmp = regs->RTCCR;
    tmp = tmp | 0x1;
    regs->RTCCR = tmp;
}

static irqreturn_t rtc_alarm_handler(int irq, void *dev_id)
{

    cur_time = regs->RTCDR;
    rtc_time_translate();
    printk("\nalarm: beep~ beep~ \n");
    printk("\n    %d:%d:%d\n", tm.hour, tm.min, tm.sec);
    regs->RTCICR = 1;
    set_rtc_alarm();
    return IRQ_HANDLED;
}


static struct dentry *rtc_root;
static struct dentry *reg_dir;
static u32 *reg_p = NULL;

static int __init rtc_init(void)
{
    int ret = 0;
    
    regs = (rtc_reg_t *)ioremap(RTC_BASE, sizeof(rtc_reg_t));
    printk("rtc_init\n");

    ret = alloc_chrdev_region(&devno, 0, 1, "rtc-demo");
    if (ret) {
        printk("alloc char device number failed!\n");
        return ret;
    }
    printk("RTC devnum:%d minornum:%d\n", MAJOR(devno), MINOR(devno));

    rtc_cdev = cdev_alloc();
    cdev_init(rtc_cdev, &rtc_fops);

    ret = cdev_add(rtc_cdev, devno, 1);
    if (ret < 0) {
        printk("cdev_add failed..\n");
        return -ret;
    }
    else {
        printk("Register char module: rtc success!\n");
    }
    
    ret = request_irq(39, rtc_alarm_handler, 0, "rtc-test", NULL);
    if (ret == -1) {
        printk("request_irq failed!\n");
        return -ret;
    }

    rtc_root = debugfs_create_dir("rtc", NULL);
    if (IS_ERR(rtc_root)) {
        pr_err("%s: create rtc dir failed\n", __func__);
        return PTR_ERR(rtc_root);
    }
    reg_dir = debugfs_create_dir("reg_list", rtc_root);
    if (IS_ERR(reg_dir)) {
        pr_err("%s: create reg dir failed\n", __func__);
        return PTR_ERR(reg_dir);
    }

    reg_p =(u32 *) regs;
    // 使用的接口函数为debugfs_create_x32，即导出一个地址，可读可写.
    debugfs_create_x32("RTCDR", 0644, reg_dir, reg_p);
    debugfs_create_x32("RTCMR", 0644, reg_dir, reg_p + 0x01);
    debugfs_create_x32("RTCLR", 0644, reg_dir, reg_p + 0x02);
    debugfs_create_x32("RTCCR", 0644, reg_dir, reg_p + 0x03);
    debugfs_create_x32("RTCIMSC", 0644, reg_dir, reg_p + 0x04);
    debugfs_create_x32("RTCRIS", 0644, reg_dir, reg_p + 0x05);
    debugfs_create_x32("RTCMIS", 0644, reg_dir, reg_p + 0x06);
    debugfs_create_x32("RTCICR", 0644, reg_dir, reg_p + 0x07);


    set_rtc_alarm();

    return 0;
}

static void __exit rtc_exit(void)
{
    if (rtc_root)
        debugfs_remove_recursive(rtc_root);

    free_irq(39, NULL);
    cdev_del(rtc_cdev);
    unregister_chrdev_region(devno, 1);
}

module_init(rtc_init);
module_exit(rtc_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("wit@zhaixue.cc");

十四、通过debugfs导出调试接口

通过debugfs导出调试接口之后，用户调试程序就可以通过/sys/kernel/debugfs下的文件来对接口的功能进行测试了。

#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/module.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/interrupt.h>

typedef volatile struct {
        unsigned int  RTCDR;    /* +0x00: data register */
        unsigned int  RTCMR;    /* +0x04: match register */
        unsigned int  RTCLR;    /* +0x08: load register */
        unsigned int  RTCCR;    /* +0x0C: control register */
        unsigned int  RTCIMSC;  /* +0x10: interrupt mask set and clear register*/
        unsigned int  RTCRIS;   /* +0x14: raw interrupt status register*/
        unsigned int  RTCMIS;   /* +0x18: masked interrupt status register */
        unsigned int  RTCICR;   /* +0x1C: interrupt clear register */
}rtc_reg_t;

struct rtc_time {
    unsigned int year;
    unsigned int mon;
    unsigned int day;
    unsigned int hour;
    unsigned int min;
    unsigned int sec;
};

#define RTC_BASE 0x10017000

#define CUR_TIME_CMD   1      /* command for set/get current time */
#define ALARM_TIME_CMD 2      /* command for set/get alarm time */

static volatile rtc_reg_t *regs = NULL;
static unsigned long cur_time = 0;   /* current time */
static unsigned long alarm_time = 0; /* alarm time  */
static struct rtc_time tm; /* global time */
static char rtc_buf[64]; /* buffer for time string input from user space */

static void rtc_time_to_tm(unsigned long time)
{
    tm.hour = (time % 86400) / 3600;
    tm.min  = (time % 3600) / 60;
    tm.sec = time % 60;
}

static void rtc_tm_to_time(unsigned long *time)
{
    *time = tm.hour * 3600 + tm.min * 60 + tm.sec;
}

static void rtc_string_to_tm(void)
{
    tm.hour = (rtc_buf[0] - '0') * 10 + (rtc_buf[1] - '0');
    tm.min  = (rtc_buf[2] - '0') * 10 + (rtc_buf[3] - '0');
    tm.sec  = (rtc_buf[4] - '0') * 10 + (rtc_buf[5] - '0');
}

static void rtc_tm_to_string(void)
{
    rtc_buf[0] = tm.hour / 10 + '0';
    rtc_buf[1] = tm.hour % 10 + '0';
    rtc_buf[2] = tm.min / 10 + '0';
    rtc_buf[3] = tm.min % 10 + '0';
    rtc_buf[4] = tm.sec / 10 + '0';
    rtc_buf[5] = tm.sec % 10 + '0';
    rtc_buf[6] = '\n';
    rtc_buf[7] = '\0';
}


static dev_t devno;
static struct cdev *rtc_cdev;

static int rtc_open(struct inode *inode, struct file *fp)
{
    return 0;
}

static int rtc_release(struct inode *inode, struct file *fp)
{
    return 0;
}

static ssize_t rtc_read(struct file *fp, char __user *buf, 
                           size_t size, loff_t *pos)
{

    cur_time = regs->RTCDR;
    rtc_time_to_tm(cur_time);
    if (copy_to_user(buf, &tm, sizeof(struct rtc_time)) != 0){
        printk("rtc_read error!\n");
        return -1;
    }

    return sizeof(struct rtc_time);
}

static ssize_t rtc_write(struct file *fp, const char __user *buf, 
                            size_t size, loff_t *pos)
{
    int len = 0;
    
    len = sizeof(struct rtc_time);
    if (copy_from_user(&tm, buf, len) != 0) {
        printk("rtc_write error!\n");
        return -1;
    }
    rtc_tm_to_time(&cur_time);
    regs->RTCLR = cur_time;

    return len;
}

/* standard file I/O system call */
static const struct file_operations rtc_fops = {
    .owner   = THIS_MODULE,
    .read    = rtc_read,
    .write   = rtc_write,
    .open    = rtc_open,
    .release = rtc_release,
};


static void set_rtc_alarm(void)
{
    unsigned int tmp = 0;
    
    tmp = regs->RTCCR;
    tmp = tmp & 0xFFFFFFFE;
    regs->RTCCR = tmp;


    cur_time = regs->RTCDR;
    regs->RTCMR = alarm_time;

    regs->RTCICR = 1;
    regs->RTCIMSC = 1;

    tmp = regs->RTCCR;
    tmp = tmp | 0x1;
    regs->RTCCR = tmp;
}

static irqreturn_t rtc_alarm_handler(int irq, void *dev_id)
{

    cur_time = regs->RTCDR;
    rtc_time_to_tm(cur_time);
    printk("\nalarm: beep~ beep~ \n");
    printk("\n    %d:%d:%d\n", tm.hour, tm.min, tm.sec);
    regs->RTCICR = 1;

    return IRQ_HANDLED;
}

static ssize_t rtc_debugfs_read(struct file *filp, char __user *buf,
                                size_t count, loff_t *ppos, int cmd)
{
    int ret;

    if (*ppos >= 64)
        return 0;
    if (*ppos + count > 64)
        count = 64 - *ppos;

    if (cmd == CUR_TIME_CMD) {
        cur_time = regs->RTCDR;
        rtc_time_to_tm(cur_time);
    }

    if (cmd == ALARM_TIME_CMD) {
        alarm_time = regs->RTCMR;
        rtc_time_to_tm(alarm_time);
    }

    rtc_tm_to_string();

    ret = copy_to_user(buf, rtc_buf, count);
    if (ret)
        return -EFAULT;
   *ppos += count;

    return count;
}

static ssize_t rtc_debugfs_write(struct file *filp, const char __user *buf, 
                                     size_t count, loff_t *ppos, int cmd)
{
    int ret;
    
    if (*ppos > 64)
        return 0;
    if (*ppos + count > 64)
        count = 64 - *ppos;
    
    ret = copy_from_user(rtc_buf, buf, count);
    if (ret)
        return -EFAULT;
    *ppos += count;

    rtc_string_to_tm();

    if (cmd == CUR_TIME_CMD) {
        rtc_tm_to_time(&cur_time);
        regs->RTCLR = cur_time;
    }

    if (cmd == ALARM_TIME_CMD) {
        rtc_tm_to_time(&alarm_time);
        set_rtc_alarm();
    }

    return count;
}


/* set current time interface */
static ssize_t rtc_cur_time_read(struct file *filp, char __user *buf, 
                                     size_t count, loff_t *ppos)
{
    return rtc_debugfs_read(filp, buf, count, ppos, CUR_TIME_CMD);
}

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

static const struct file_operations rtc_cur_time_fops = {
    .read    = rtc_cur_time_read,
    .write   = rtc_cur_time_write,
};


/* set alarm time interface */
static ssize_t rtc_alarm_time_read(struct file *filp, char __user *buf, 
                                     size_t count, loff_t *ppos)
{
    return rtc_debugfs_read(filp, buf, count, ppos, ALARM_TIME_CMD);
}

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

static const struct file_operations rtc_alarm_time_fops = {
    .read    = rtc_alarm_time_read,
    .write   = rtc_alarm_time_write,
};



static struct dentry *rtc_root;
static struct dentry *reg_dir;
static u32 *reg_p = NULL;

static int __init rtc_init(void)
{
    int ret = 0;
    
    regs = (rtc_reg_t *)ioremap(RTC_BASE, sizeof(rtc_reg_t));
    printk("rtc_init\n");

    ret = alloc_chrdev_region(&devno, 0, 1, "rtc-demo");
    if (ret) {
        printk("alloc char device number failed!\n");
        return ret;
    }
    printk("RTC devnum:%d minornum:%d\n", MAJOR(devno), MINOR(devno));

    rtc_cdev = cdev_alloc();
    cdev_init(rtc_cdev, &rtc_fops);

    ret = cdev_add(rtc_cdev, devno, 1);
    if (ret < 0) {
        printk("cdev_add failed..\n");
        return -ret;
    }
    else {
        printk("Register char module: rtc success!\n");
    }
    
    ret = request_irq(39, rtc_alarm_handler, 0, "rtc-test", NULL);
    if (ret == -1) {
        printk("request_irq failed!\n");
        return -ret;
    }

    rtc_root = debugfs_create_dir("rtc", NULL);
    if (IS_ERR(rtc_root)) {
        pr_err("%s: create rtc dir failed\n", __func__);
        return PTR_ERR(rtc_root);
    }
    reg_dir = debugfs_create_dir("reg_list", rtc_root);
    if (IS_ERR(reg_dir)) {
        pr_err("%s: create reg dir failed\n", __func__);
        return PTR_ERR(reg_dir);
    }

    reg_p =(u32 *) regs;
    debugfs_create_x32("RTCDR", 0644, reg_dir, reg_p);
    debugfs_create_x32("RTCMR", 0644, reg_dir, reg_p + 0x01);
    debugfs_create_x32("RTCLR", 0644, reg_dir, reg_p + 0x02);
    debugfs_create_x32("RTCCR", 0644, reg_dir, reg_p + 0x03);
    debugfs_create_x32("RTCIMSC", 0644, reg_dir, reg_p + 0x04);
    debugfs_create_x32("RTCRIS", 0644, reg_dir, reg_p + 0x05);
    debugfs_create_x32("RTCMIS", 0644, reg_dir, reg_p + 0x06);
    debugfs_create_x32("RTCICR", 0644, reg_dir, reg_p + 0x07);

    debugfs_create_file("cur_time", 0644, rtc_root, NULL, &rtc_cur_time_fops);
    debugfs_create_file("alarm_time", 0644, rtc_root, 
                          NULL, &rtc_alarm_time_fops);
    
    return 0;
}

static void __exit rtc_exit(void)
{
    if (rtc_root)
        debugfs_remove_recursive(rtc_root);

    free_irq(39, NULL);
    cdev_del(rtc_cdev);
    unregister_chrdev_region(devno, 1);
}

module_init(rtc_init);
module_exit(rtc_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("wit@zhaixue.cc");
中度拖延症患者
关注
  • 5
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Debugfs文件系统的简介及简单使用
weixin_43083491的博客
04-02 4625
我还在读取一个又一个寄存器查gpio配置的时候，大佬，一下清晰明了的搞定了。会的就是多呀。 学习了。
debugfs
ddddfang的专栏
04-21 1365
在调试linux驱动的时候，可以用debugfs来调试，debugfs类似字符设备驱动一样，甚至更简单，不需要主设备号次设备号等等，只需要实现一个file_operations，然后通过debugfs_create_file就可以在debugfs中建立一个文件结点，就像字符设备驱动那样，只需要对这个文件结点进行open就可以进行read、write、ioctl，等等操作，这些操作对应到我们在驱动里为debugfs准备的file_operations。 让内核支持DEBUGFS，使能宏CONFIG_DEBU
Linux内核里的DebugFS
weixin_30571465的博客
01-17 1378
DebugFS，顾名思义，是一种用于内核调试的虚拟文件系统，内核开发者通过debugfs和用户空间交换数据。类似的虚拟文件系统还有procfs和sysfs等，这几种虚拟文件系统都并不实际存储在硬盘上，而是Linux内核运行起来后才建立起来。 通常情况下，最常用的内核调试手段是printk。但printk并不是所有情况都好用，比如打印的数据可能过多，我们真正关心的数据在大量的输出里不是那么一目了然...
debugfs恢复linux上rm误删的文件
dengdiaoji9507的博客
09-02 549
前情 因手快误将Linux系统上辛苦编写的代码直接rm误删，由于未将代码更新到git，代码改动又比较大，重写起来太费劲，因此想着怎样才能恢复误删的文件。 网上查了许多资料，目前总结出一个比较实用于自己的恢复方法，记录于此： 神器debugfs 1 执行sudo debugfs -w /dev/sda1 命令，进入debugfs模式，其中sda1是你所在的分区，因...
Linux Debugfs 虚拟文件系统
uunubt的专栏
10-12 942
Debugfs 是内核开发人员向用户空间提供信息的一种简单方法。/proc 仅用于提供有关进程的信息，或者 sysfs 具有严格的每个文件一个值的规则，而 debugfs 则完全没有规则。开发人员可以将他们想要的任何信息放在那里。debugfs 文件系统也不能作为用户空间的稳定 ABI；理论上，在那里导出的文件没有稳定性限制。现实世界并不总是那么简单，即使是 debugfs 接口，最好的设计也是考虑到它们需要永远维护。(或等效的 /etc/fstab 行）。
Linux中debugfs的解析
涛声依旧的专栏
06-27 6489
debugfs_create_dir和debugfs_create_file定义在fs/debugfs/inode.c，声明在include/linux/debugfs.h。 struct dentry *debugfs_create_dir(const char *name, struct dentry *parent) { return __create_file(name, S_IF
spy:Linux内核模式debugfs键盘记录器
04-22
这也是针对愿意学习Linux内核模块编程的开发人员的学术项目，其中包含大量注释，checkpatch.pl扫描的代码，符合标准的Makefile和DKMS支持。 spy最初是为美国键盘（和兼容笔记本电脑）编写的。 默认情况下，它为按下...
bfad_debugfs.rar_驱动编程_Unix_Linux_
08-11
`bfad_debugfs`是针对这种硬件设备的一个特定驱动程序，它利用了Unix和Linux内核的调试文件系统——debugfs。下面将详细介绍这个领域的相关知识点。 首先，`bfad_debugfs.c`是驱动程序的核心源代码文件，它包含了...
qib_debugfs.rar_Linux/Unix编程_Unix_Linux_
08-11
在Linux和Unix操作系统中，调试是开发者不可或缺的工具，而`debugfs`是Linux内核提供的一种虚拟文件系统，主要用于内核调试。标题中的"qib_debugfs.rar_Linux/Unix编程_Unix_Linux_"表明这是一个与Linux内核调试相关...
kernel_modules:linux内核模块编程示例程序
07-20
- `debugfs`文件系统提供了一种在内核中创建调试文件的方法。 - `module_param`宏允许通过命令行参数传递值给内核模块。 - `kprobes`和`kretprobes`用于动态探测内核函数调用。 在`kernel_modules-master`这个...
Linux驱动_debugfs1
08-08
2. debugfs示例代码#include <linux/kernel.h>#include <linux/module.h>#include <linux/
轻松与Linux内核交流.pdf
09-06
Linux内核提供了多种方式供用户空间的应用程序与内核进行通信，包括基于虚拟文件系统的接口（如sysfs、procfs、debugfs）和基于socket编程的netlink、genetlink等。 首先，系统调用是内核与用户空间通信的基础，是...
Linux 创建 debugfs 调试节点
EricTsai的专栏
05-09 500
debugfs是一个Linux内核提供的虚拟文件系统，旨在为内核开发人员提供一个调试接口。它可以在运行时动态地创建文件和目录，这些文件和目录与内核数据结构相关联，以提供对内核信息的实时访问。通过debugfs，开发人员可以方便地查看和修改内核数据结构，例如文件系统进程列表驱动程序状态等等。内核提供了大量的debugfs接口，以便开发人员创建、删除、读取和写入文件，以及管理文件权限所有权和其他属性。这些接口包括等等。通过debugfs，开发人员可以方便地调试内核问题，以及开发和测试内核驱动程序。
Linux驱动调试中的Debugfs的使用简介
ll148305879的博客
06-04 2794
在调试linux驱动的时候，可以用debugfs来调试，debugfs类似字符设备驱动一样，甚至更简单，不需要主设备号次设备号等等，只需要实现一个file_operations，然后通过debugfs_create_file就可以在debugfs中建立一个文件结点，就像字符设备驱动那样，只需要对这个文件结点进行open就可以进行read、write、ioctl，等等操作，这些操作对应到我们在驱动里...
kernel文件动态调试功能 -- dynamic_debug 打开及半闭
manshq163com的专栏
06-13 1844
kernel文件动态调试功能 -- dynamic_debug 打开及半闭2015年11月06日 10:10:53阅读数：2025 Kernel def_config中需要打开以下两个宏CONFIG_DEBUG_FS=yCONFIG_DYNAMIC_DEBUG=y (1)step1:open pr_debugadb rootadb remountadb shell打开动态调试#echo 'file...
Linux驱动——debugfs接口创建
嵌入式Linux充电站
04-05 549
上篇介绍了procfs接口的创建，今天再介绍一种debugfs接口的创建。实现效果：在`/sys/kernel/debug/`目录下创建一个`ion/test`文件，通过`cat`、`echo`的方式进行读写操作。前期准备 ：内核配置打开debugfs：CONFIG_DEBUG_FS=y。挂载debugfs文件系统：mount -t debugfs none /sys/kernel/debug
RK3399平台开发系列讲解（内核篇）13. debugfs调试文件系统
最新发布
一直在水些技术小文
09-25 66
在RK3399平台内核开发过程中，debugfs调试文件系统是一种非常有用的工具。它提供了一种简单而强大的方式，可以让我们在运行时查看内核数据、调试代码、分析性能，并且不会对系统产生太大影响。本文将介绍debugfs的基本概念和使用方法，并配上一个实例演示如何在RK3399平台内核中使用debugfs进行调试。debugfs调试文件系统是Linux内核中的一个虚拟文件系统，它可以让开发者在运行时访问内核数据和调试信息。
linux的内核调试：debugfs文件系统
qq_36187809的博客
02-20 989
Linux驱动调试中的Debugfs的使用简介 (2012-03-31 14:14) 在调试linux驱动的时候，可以用debugfs来调试，debugfs类似字符设备驱动一样，甚至更简单，不需要主设备号次设备号等等，只需要实现一个file_operations，然后通过debugfs_create_file就可以在debugfs中建立...
【TINY4412】LINUX学习笔记：（4）sysfs、debugfs、procfs文件系统
大水猫
01-16 550
【TINY4412】LINUX学习笔记：（4）procfs、sysfs、debugfs 文件系统 宿主机 ： 虚拟机 Ubuntu 16.04 LTS / X64 目标板[底板]： Tiny4412SDK - 1506 目标板[核心板]： Tiny4412 - 1412 LINUX内核： 4.12.0 交叉编译器： a
探索Linux内核编程深度：系统调用与文件I/O详解
该书聚焦于Linux内核层面的编程，对于深入理解Linux操作系统底层机制具有很高的价值。作为一本参考图书，它特别适合那些对系统级编程和Linux内核感兴趣的运维和技术人员。 在书中，作者首先从基础开始，讲解了Linux...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值