精华内容
下载资源
问答
  • DebugFS

    2012-11-06 10:50:57
    DebugFS,顾名思义,是一种用于内核调试的虚拟文件系统,内核开发者通过debugfs和用户空间交换数据。类似的虚拟文件系统还有procfs和sysfs等,这几种虚拟文件系统都并不实际存储在硬盘上,而是Linux内核运行起来后才...

    DebugFS,顾名思义,是一种用于内核调试的虚拟文件系统,内核开发者通过debugfs和用户空间交换数据。类似的虚拟文件系统还有procfs和sysfs等,这几种虚拟文件系统都并不实际存储在硬盘上,而是Linux内核运行起来后才建立起来。

    通常情况下,最常用的内核调试手段是printk。但printk并不是所有情况都好用,比如打印的数据可能过多,我们真正关心的数据在大量的输出里不是那么一目了然;或者我们在调试时可能需要修改某些内核变量,这种情况下printk就无能为力,而如果为了修改某个值重新编译内核或者驱动又过于低效,此时就需要一个临时的文件系统可以把我们需要关心的数据映射到用户空间。在过去,procfs可以实现这个目的,到了2.6时代,新引入的sysfs也同样可以实现,但不论是procfs或是sysfs,用它们来实现某些debug的需求,似乎偏离了它们创建的本意。比如procfs,其目的是反映进程的状态信息;而sysfs主要用于Linux设备模型。不论是procfs或是sysfs的接口应该保持相对稳定,因为用户态程序很可能会依赖它们。当然,如果我们只是临时借用procfs或者sysfs来作debug之用,在代码发布之前将相关调试代码删除也无不可。但如果相关的调试借口要在相当长的一段时间内存在于内核之中,就不太适合放在procfs和sysfs里了。故此,debugfs应运而生。

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

    # mount -t debugfs none /your/debugfs/dir

    Linux内核为debugfs提供了非常简洁的API,本文接下来将以一个实作为例来介绍,sample code可以从这里下载。

    这个实作会在debugfs中建立如下的目录结构:

    其中,a对应模块中的一个u8类型的变量,b和subdir下面的c都是对应模块里的一个字符数组,只是它们的实现方式不同。

    在module_init里,我们首先要建立根目录mydebug:

    1
    my_debugfs_root = debugfs_create_dir("mydebug", NULL);

    第一个参数是目录的名称,第二个参数用来指定这个目录的上级目录,如果是NULL,则表示是放在debugfs的根目录里。

    子目录也是用debugfs_create_dir来实现:

    1
    sub_dir = debugfs_create_dir("subdir", my_debugfs_root);

    建立文件a的代码非常简单:

    1
    debugfs_create_u8("a", 0644, my_debugfs_root, &a);

    这表示文件名为“a”,文件属性是0644,父目录是上面建立的“mydebug”,对应的变量是模块中的a。

    Linux内核还提供了其他一些创建debugfs文件的API,请参考本文的附录。

    b是一个32-bytes的字符数组,在debugfs里,数组可以用blob wrapper来实现。

    1
    2
    3
    4
    5
    6
    char hello[32] = "Hello world!\n";
    struct debugfs_blob_wrapper b;
    b.data = (void *)hello;
    b.size = strlen(hello) + 1;
    debugfs_create_blob("b", 0644, my_debugfs_root, &b);

    这里需要注意的是,blob wrapper定义的数据只能是只读的。在本例中,虽然我们把文件b的权限设定为0644,但实际这个文件还是只读的,如果试图改写这个文件,系统将提示出错。

    如果需要对内核数组进行写的动作,blob wrapper就无法满足要求,我们只能通过自己定义文件操作来实现。在这个实作里,可以参考文件c的实现。c和b在模块里对应着同一块字符数组,不同的是,b是只读的,而c通过自定义的文件操作同时实现了读和写。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    static int c_open(struct inode *inode, struct file *filp)
    {
        filp->private_data = inode->i_private;
        return 0;
    }
    static ssize_t c_read(struct file *filp, char __user *buffer,
            size_t count, loff_t *ppos)
    {
        if (*ppos >= 32)
            return 0;
        if (*ppos + count > 32)
            count = 32 - *ppos;
        if (copy_to_user(buffer, hello + *ppos, count))
            return -EFAULT;
        *ppos += count;
        return count;
    }
    static ssize_t c_write(struct file *filp, const char __user *buffer,
            size_t count, loff_t *ppos)
    {
        if (*ppos >= 32)
            return 0;
        if (*ppos + count > 32)
            count = 32 - *ppos;
        if (copy_from_user(hello + *ppos, buffer, count))
            return -EFAULT;
        *ppos += count;
        return count;
    }
    struct file_operations c_fops = {
        .owner = THIS_MODULE,
        .open = c_open,
        .read = c_read,
        .write = c_write,
    };
    debugfs_create_file("c", 0644, sub_dir, NULL, &c_fops);

    注:代码里,c_open其实并没有任何用处,因为c_read和c_write直接引用了全局变量hello。这里,我们也可以换一种写法,在read/write函数里用filp->private_data来引用字符数组hello。

    到这里,三个文件和子目录已经创建完毕。在module_exit中,我们要记得释放创建的数据。

    1
    debugfs_remove_recursive(my_debugfs_root);

    debugfs_remove_recursive可以帮我们逐步移除每个分配的dentry,如果您想一个一个手动的移除,也可以直接调用debugfs_remove。

    附录:

    创建和撤销目录及文件

    1
    2
    3
    4
    5
    6
    struct dentry *debugfs_create_dir(const char *name, struct dentry *parent);
    struct dentry *debugfs_create_file(const char *name, mode_t mode,
            struct dentry *parent, void *data,
            const struct file_operations *fops);
    void debugfs_remove(struct dentry *dentry);
    void debugfs_remove_recursive(struct dentry *dentry);

    创建单值文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    struct dentry *debugfs_create_u8(const char *name, mode_t mode,
            struct dentry *parent, u8 *value);
    struct dentry *debugfs_create_u16(const char *name, mode_t mode,
            struct dentry *parent, u16 *value);
    struct dentry *debugfs_create_u32(const char *name, mode_t mode,
            struct dentry *parent, u32 *value);
    struct dentry *debugfs_create_u64(const char *name, mode_t mode,
            struct dentry *parent, u64 *value);
    struct dentry *debugfs_create_x8(const char *name, mode_t mode,
            struct dentry *parent, u8 *value);
    struct dentry *debugfs_create_x16(const char *name, mode_t mode,
            struct dentry *parent, u16 *value);
    struct dentry *debugfs_create_x32(const char *name, mode_t mode,
            struct dentry *parent, u32 *value);
    struct dentry *debugfs_create_size_t(const char *name, mode_t mode,
            struct dentry *parent, size_t *value);
    struct dentry *debugfs_create_bool(const char *name, mode_t mode,
            struct dentry *parent, u32 *value);

    其中,后缀为x8、x16、x32的这三个函数是指debugfs中的数据用十六进制表示。

    创建BLOB文件

    1
    2
    3
    4
    5
    6
    7
    struct debugfs_blob_wrapper {
        void *data;
        unsigned long size;
    };
    struct dentry *debugfs_create_blob(const char *name, mode_t mode,
             struct dentry *parent, struct debugfs_blob_wrapper *blob);

    其它

    1
    2
    3
    4
    5
    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

    2011-06-03 17:27:00
    http://blog.richliu.com/2010/01/20/843/ 以前都習慣用 printk 和 /proc 做輸入輸出的動作, 不過 debugfs 看起來是 User space ... 先確認 Enable Kernel debugfs Function Kernel hacking —> -*- Debug F...

    http://blog.richliu.com/2010/01/20/843/

    以前都習慣用 printk 和 /proc 做輸入輸出的動作, 不過 debugfs 看起來是 User space 和 kernel space 交流更好的選擇.

    先確認 Enable Kernel debugfs Function

    Kernel hacking —>
    -*- Debug Filesystem

    先來個簡單的範例,
    在你要 debug 的 modules 內, 加入 debugfs 的 include file

    #include <linux/debugfs.h>

    要將想要輸出的變數, 假設叫 pcie0_linked 輸出到 debugfs 上, 在 initial code 的地方加上
    debugfs_create_u32("pcie0_linked", 0644, NULL, &pcie0_linked);

    接下來就可以重開機了 load 新 kernel 了,

    mount debugfs

    $ mount -t debugfs debug /debugfs

    或是寫在 /etc/fstab

    debugfs /debugfs debugfs debug

    這時就可以 ls /debugfs/ , 就會出現 pcie0_linked 的檔案.

    $ cat /debugfs/pcie0_linked
    1
    $ echo 0 > /debugfs/pcie0_linked
    $ cat /debugfs/pcie0_linked
    0

    像是 procfs 一樣, debugfs 也有 create directory 的 function, 以便讓變數可以在目錄內
    我們小小改一下上面的程式, 加上 create_dir 的功能

    struct dentry *pcie_dir;
    pcie_dir = debugfs_create_dir("pcie",NULL);
    if( pcie_dir != NULL ) {
    debugfs_create_u32("pcie0_linked", 0644, pcie_dir, &pcie0_linked);
    }

    改了以上的輸出, 接下來就可以在 /debugfs 下, 看到多了一個 pcie 的目錄, 而 pcie0_linked 就在裡面.

    如果想用 hex(16 進位), 可以改用 debugfs_create_x32.

    proc file system 最棒的就是可以讀寫檔案了, 可以做更多的控制.
    debugfs 也有一個 function 可以讓使用者做檔案讀寫, 這邊寫一個簡單的 sample.

    多 include 一個 header

    #include <linux/seq_file.h>

    static int pcie_reg_open(struct seq_file *s, void *data)
    {
    seq_printf(s, "pcie0_link status : %s\n", pcie0_linked == 1 ? "Enable": "D
    return 0;
    }

    static int pcie_single_open(struct inode *inode, struct file *file)
    {
    return single_open(file, pcie_reg_open, inode->i_private);
    }
    static ssize_t pcie_debug_write(struct file *file,
    const char __user *userbuf,
    size_t count, loff_t *ppos)
    {
    char buf[20];

    if (copy_from_user(buf, userbuf, min(count, sizeof(buf))))
    return -EFAULT;

    printk("%s: %s \n",__FUNCTION__, buf);

    return count;
    }

    static const struct file_operations pcie_ios_fops = {
    .open = pcie_single_open,
    .read = seq_read,
    .write = pcie_debug_write,
    .llseek = seq_lseek,
    .release = single_release,

    };
    debugfs_create_file("file", 0644, pcie_dir, NULL, &pcie_ios_fops);

    這樣

    $ cat /debugs/pcie/file 會顯示
    pcie0_link status : Enable

    $ echo "richliu" > /debugfs/pcie/file 會顯示
    pcie_debug_write: richliu

    $

    最後要介紹的是比較特別的一種格式 blob, 這是可以傳 binary 到 user space 的格式, blob 的 struct 是
    struct debugfs_blob_wrapper {
    void *data;
    unsigned long size;
    };

    在剛剛的 Code 加上

    static struct debugfs_blob_wrapper blob; –> 最好放 global.
    char data[100];
    sprintf(data, "Data Pointer is : %08X \n", data);
    blob.data = data;
    blob.size = 100;
    debugfs_create_blob("blob", S_IRUSR, pcie_dir, &blob);

    在 Linux 下直接用 hexdump 去讀資料出來

    $ hexdump /debugfs/pcie/blob -c
    0000000 D a t a P o i n t e r i s
    0000010 : C 4 0 5 C 1 6 0 \n \0 \0 \0 \0
    0000020 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0
    *
    0000060

    請記得 Blob 這個檔案是 Read Only, 只能傳出, 不能傳入…

    參考:
    Debugfs
    Debugfs 中譯版(好像是從匪區抄過來的?)

    展开全文
  • debugfs

    2016-12-02 15:53:35
    在进行系统调试的时候,有可能会使用到debug file system。 下面讲解如何具体使用debug file system 1. 在kernel中使用debug file system ...Kernel hacking --> 选中Debug Filesystem (CONFIG_DEBUG_FS)选项。 [On

    在进行系统调试的时候,有可能会使用到debug file system。

    下面讲解如何具体使用debug file system

    1. 在kernel中使用debug file system

    [On Linux 2.6.39]

        make menuconfig --> Kernel hacking --> 选中Debug Filesystem (CONFIG_DEBUG_FS)选项。

    [On Linux 3.12-rc2]

    [this commit: 6dfc0665 add the Compile-time checks and compiler options]

        make menuconfig --> kernel hacking --> Compile-time checks and compiler options --> 选中Debug Filesystem (CONFIG_DEBUG_FS)选项。


        make menuconfig --> kernel hacking --> 选中Kernel debugging (CONFIG_DEBUG_KERNEL)选 项。


        :"kernel debugging"选项必须使能,否则在进行第三步的时候,会报“mount: unknown filesystem type 'debugfs'

    2. 编译kernel,下载并且运行之。

    3. 挂载debug file system

        # mount -t debugfs none /sys/kernel/debug

    或者

        # mkdir /debug

        # mount -t debugfs none /debug

        进入/debug文件夹及其子文件夹获得想要的信息
    展开全文
  • Linux中debugfs的解析 2016年06月27日 17:56:17 阅读数:1088 debugfs_create_dir和debugfs_create_file定义在fs/debugfs/inode.c,函数原型声明在include/linux/fs.h。 struct dentry *debugfs_create_dir...

    Linux中debugfs的解析

    2016年06月27日 17:56:17

    阅读数:1088

    debugfs_create_dir和debugfs_create_file定义在fs/debugfs/inode.c,函数原型声明在include/linux/fs.h。

    struct dentry *debugfs_create_dir(const char *name, struct dentry *parent);
    struct dentry *debugfs_create_file(const char *name, umode_t mode, struct dentry *parent, void *data, const struct file_operations *fops);
    name是创建的文件或目录的名字,mode是文件的权限,parent是父目录,data通常指向驱动程序分配的数据,fops指向驱动分配的file_operations结构体,该结构体指定了应用程序读写时对调用的驱动程序函数。
    对应的remove函数:
    void debugfs_remove_recursive(struct dentry *dentry);
    参数是调用debugfs_create_dir函数返回的指针。

    配置CONFIG_DEBUG_FS=y让内核支持debugfs,也可以在menuconfig中指定:
    Kernel hacking  --->
        [*] Debug Filesystem
    内核默认会将debugfs挂载在/sys/kernel/debug目录下,也可以指定挂载目录:mount -t debugfs none /mnt
    使用debugfs文件系统调试,先用宏DEFINE_SIMPLE_ATTRIBUTE指定使用读写函数和可变参数的格式,然后调用debugfs_create_dir和debugfs_create_file在文件系统下面创建文件,执行cat和echo时,会调用驱动的读写函数。

    DEFINE_SIMPLE_ATTRIBUTE宏定义在include/linux/fs.h。
    #define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt)        \
    static int __fops ## _open(struct inode *inode, struct file *file)    \
    {                                    \
        __simple_attr_check_format(__fmt, 0ull);            \
        return simple_attr_open(inode, file, __get, __set, __fmt);    \
    }                                    \
    static const struct file_operations __fops = {                \
        .owner     = THIS_MODULE,                        \
        .open     = __fops ## _open,                    \
        .release = simple_attr_release,                    \
        .read     = simple_attr_read,                    \
        .write     = simple_attr_write,                    \
        .llseek     = generic_file_llseek,                    \
    };

    DEFINE_SIMPLE_ATTRIBUTE定义了一个file_operations结构体,并指定了open,read,write等函数,simple_attr_open函数关联了驱动的read,write函数,应用程序read,write时,通过simple_attr_read和simple_attr_write来调用驱动程序的read,write函数。
    int simple_attr_open(struct inode *inode, struct file *file, int (*get)(void *, u64 *), int (*set)(void *, u64), const char *fmt)
    {
        struct simple_attr *attr;

        attr = kmalloc(sizeof(*attr), GFP_KERNEL);
        if (!attr)
            return -ENOMEM;

        attr->get = get;
        attr->set = set;
        attr->data = inode->i_private;
        attr->fmt = fmt;
        mutex_init(&attr->mutex);

        file->private_data = attr;

        return nonseekable_open(inode, file);
    }

    attr->get和attr->set分别指向驱动的get和set函数。attr->data指向了驱动分配的数据,在调用debugfs_create_file时,该函数会inode->i_private指正指向第四个参数,这个参数一般是驱动程序的数据指针。
    ssize_t simple_attr_read(struct file *file, char __user *buf,
                 size_t len, loff_t *ppos)
    {
        struct simple_attr *attr;
        size_t size;
        ssize_t ret;

        attr = file->private_data;

        if (!attr->get)
            return -EACCES;

        ret = mutex_lock_interruptible(&attr->mutex);
        if (ret)
            return ret;

        if (*ppos) {        /* continued read */
            size = strlen(attr->get_buf);
        } else {        /* first read */
            u64 val;
            ret = attr->get(attr->data, &val);
            if (ret)
                goto out;

            size = scnprintf(attr->get_buf, sizeof(attr->get_buf),
                     attr->fmt, (unsigned long long)val);
        }

        ret = simple_read_from_buffer(buf, len, ppos, attr->get_buf, size);
    out:
        mutex_unlock(&attr->mutex);
        return ret;
    }

    通过attr = file->private_data;获得在simple_attr_open函数分配的attr结构体地址,然后ret = attr->get(attr->data, &val);用来调用驱动的get函数,读取到的值存放在val中,最后调用scnprintf函数将val按照DEFINE_SIMPLE_ATTRIBUTE中定义的字符串格式返回到simple_attr结构体的get_buf字符数组。
    ssize_t simple_attr_write(struct file *file, const char __user *buf,
                  size_t len, loff_t *ppos)
    {
        struct simple_attr *attr;
        u64 val;
        size_t size;
        ssize_t ret;

        attr = file->private_data;
        if (!attr->set)
            return -EACCES;

        ret = mutex_lock_interruptible(&attr->mutex);
        if (ret)
            return ret;

        ret = -EFAULT;
        size = min(sizeof(attr->set_buf) - 1, len);
        if (copy_from_user(attr->set_buf, buf, size))
            goto out;

        attr->set_buf[size] = '\0';
        val = simple_strtoll(attr->set_buf, NULL, 0);
        ret = attr->set(attr->data, val);
        if (ret == 0)
            ret = len; /* on success, claim we got the whole input */
    out:
        mutex_unlock(&attr->mutex);
        return ret;
    }
    首先和simple_attr_read一样获得attr的地址,然后调用copy_from_user获得echo传入的参数,接着利用simple_strtoll将字符传格式的数字转换为整型,最后调用驱动的set函数,将值写入attr->data中。

    展开全文
  • linux debugfs

    2020-09-08 19:41:16
    Debugfs exists as a simple way for kernel developers to make information available to user space. 1. mount debugfs 1.1 no debugfs 1.2 mount mount -t debugfs none /sys/kernel/debug 2...
  • 一般我们通过下面的code来创建一个名为bongding的debugfs的入口 void bond_create_debugfs(void) {  bonding_debug_root = debugfs_create_dir("bonding", NULL);  if (!bonding_debug_root) {  pr_warn(...
  • 内核debugfs使用简介

    2020-01-17 18:05:56
    创建一个debugfs目录: struct dentry *debugfs_create_dir(const char *name, struct dentry *parent); 创建一个debugfs文件: struct dentry *debugfs_create_file(const char *name, umode_t mode, s...
  • debugfs例子程序

    2015-12-20 17:30:36
    linux文件系统中的debugfs程序小例子
  • linux debugfs system

    2019-09-17 16:21:19
    了解linux debugfs system 1.Introduction   Debugfs is a special file system available in the Linux kernel since version 2.6.10-rc3. Debugfs is a simple-to-use RAM-based file system specially ...
  • kvm debugfs 接口

    2017-02-25 22:28:28
    static int kvm_init_debug(void) { int r = -EEXIST; struct kvm_stats_debugfs_item *p;kvm_debugfs_dir = debugfs_create_dir("kvm", NULL); if (kvm_debugfs_dir == NULL) goto out;kvm_debugfs_n
  • DebugFS,是一种用于内核调试的虚拟文件系统,内核通过debugfs和用户空间交换数据。类似procfs和sysfs等,这些文件系统都在内存里。 最常用的内核调试手段是printk。但在调试时可能需要修改某些内核变量,这时...
  • Linux驱动调试中的Debugfs的使用简介 (2012-03-31 14:14)在调试linux驱动的时候,可以用debugfs来调试,debugfs类似字符设备驱动一样,甚至更简单,不需要主设备号次设备号等等,只需要实现一个file_operations,...
  • linux的debugfs机制

    2018-01-08 22:05:12
    debugfs是linux中用户层与内核层的的一种数据交互方式。 debugfs相关函数定义在 linux.debugfs.h 文件中,实现在linux.debugfs.c文件中。重要函数有下面几个。 创建和撤销目录及文件 struct dentry *debugfs_...
  • linux内核 DebugFS

    千次阅读 2017-03-29 16:33:58
    点击打开链接一、简介DebugFS,顾名思义,是一种用于内核调试的虚拟文件系统,内核开发者通过debugfs和用户空间交换数据。类似的虚拟文件系统还有procfs和sysfs等,这几种虚拟文件系统都并不实际存储在硬盘上,而是...
  • tiny4412 debugfs

    2019-11-08 21:45:30
    在文件系统里面添加debugfs vim etc/fstab #device mount-point type options dump fsck order proc /proc proc defaults 0 0 tmpfs /...
  • debugfs是ext2 ext3 ext4文件系统提供的文件系统访问工具,通过debugfs,可以不用mount文件系统就可以直接访问,但是有一点,就是用于不通过文件系统直接对文件系统格式化过的设备进行操作。blkparse将blktrace产生...
  • 在调试linux驱动的时候,可以用debugfs来调试,debugfs类似字符设备驱动一样,甚至更简单,不需要主设备号次设备号等等,只需要实现一个file_operations,然后通过debugfs_create_file就可以在debugfs中建立一个文件...
  • 在调试linux驱动的时候,可以用debugfs来调试,debugfs类似字符设备驱动一样,甚至更简单,不需要主设备号次设备号等等,只需要实现一个file_operations,然后通过debugfs_create_file就可以在debugfs中建立一个文件...
  • Linux中debugfs的解析

    千次阅读 2016-06-27 17:56:17
    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...
  • debugfs恢复文件

    千次阅读 2019-06-14 16:56:52
    debugfs open /dev/sda1 ls -d /home/user 找到丢失文件对应的<num> logdump -i <num> dd =if/dev/sda1 of=home/usrer/xx.c bs=offset count=1 skip=block <enter> 参考...
  • linux中用debugfs调试

    千次阅读 2015-07-09 10:19:20
    在调试linux驱动的时候,可以用debugfs来调试,debugfs类似字符设备驱动一样,甚至更简单,不需要主设备号次设备号等等,只需要实现一个file_operations,然后通过debugfs_create_file就可以在debugfs中建立一个文件...
  • Linux内核调试debugfs

    2019-02-18 09:46:06
    DebugFS,顾名思义,是一种用于内核调试的虚拟文件系统,内核开发者通过debugfs和用户空间交换数据。类似的虚拟文件系统还有procfs和sysfs等,这几种虚拟文件系统都并不实际存储在硬盘上,而是Linux内核运行起来后才...
  • 调试内核打印debugfs

    2017-01-29 00:11:00
    内核中也不要直接用printk,可以把想查看的数据通过debugfs来查看。 debugfs的用法和sysfs的用法相似。***在注册制好后,路径在/sys/kernel/debug路径下。 使用方法: 添加头文件<linux/debugfs.h&...
  • debugfs 分析

    千次阅读 2013-05-14 17:29:48
    作者:杨红刚,兰州大学 邮箱:eagle.rtlinux@gmail.... -------------------------------------------------------------------- ------ 怎么使用debugfs ------- ...在Documentation/filesystems/debugfs.txt中
  • Linux之debugfs介绍

    千次阅读 2015-08-12 15:44:05
    Linux之debugfs介绍 Debugfs是一种用于内核调试的虚拟文件系统,在内核源码中经常可以看到它的使用,今天我来大概介绍一下它的使用。 如果你对debugfs不熟悉,那么也许你会对sysfs比较熟悉,对于调试方面,其实两个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,880
精华内容 2,352
关键字:

debugfs