1
2
3
4

cat /proc/dummydev

irq = 20
mode = 1    

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

void main(void)
{
    char buf[100];
    int fd = open("/proc/dummydev", O_RDWR);
    read(fd, buf, 100);
    puts(buf);

    lseek(fd, 0 , SEEK_SET);
    write(fd, "33 4", 5);

    lseek(fd, 0 , SEEK_SET);
    read(fd, buf, 100);
    puts(buf);
}

 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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

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

#define PROC_DIR_NAME "proc_demo"
#define PROC_FILE_NAME "status"
#define BUF_SIZE 1024

static char kernel_buffer[BUF_SIZE];

// 回调函数：读取文件内容
static int proc_show(struct seq_file *m, void *v)
{
    seq_printf(m, "Message from kernel: %s\n", kernel_buffer);
    return 0;
}

// 回调函数：打开文件
static int proc_open(struct inode *inode, struct file *file)
{
    return single_open(file, proc_show, NULL);
}

// 回调函数：向文件写入数据
static ssize_t proc_write(struct file *file, const char __user *buf, 
                          size_t count, loff_t *ppos)
{
    size_t len = (count >= BUF_SIZE) ? BUF_SIZE - 1 : count;

    if (copy_from_user(kernel_buffer, buf, len))
        return -EFAULT;

    kernel_buffer[len] = '\0';
    printk(KERN_INFO "proc_demo: Received from user space: %s\n", kernel_buffer);

    return len;
}

// 文件操作结构体
static const struct proc_ops proc_fops = {
    .proc_open    = proc_open,
    .proc_read    = seq_read,
    .proc_write   = proc_write,
    .proc_lseek   = seq_lseek,
    .proc_release = single_release,
};

static int __init proc_demo_init(void)
{
    struct proc_dir_entry *dir, *file;

    // 1. 创建 /proc/proc_demo 目录
    dir = proc_mkdir(PROC_DIR_NAME, NULL);
    if (!dir)
        return -ENOMEM;

    // 2. 在目录下创建 /proc/proc_demo/status 文件
    file = proc_create(PROC_FILE_NAME, 0666, dir, &proc_fops);
    if (!file) {
        remove_proc_entry(PROC_DIR_NAME, NULL); // 清理已创建的目录
        return -ENOMEM;
    }

    // 初始化默认消息
    strcpy(kernel_buffer, "Hello from /proc/proc_demo/status!");

    printk(KERN_INFO "proc_demo: Directory /proc/%s created successfully\n", PROC_DIR_NAME);
    return 0;
}

static void __exit proc_demo_exit(void)
{
    // 3. 安全地删除整个目录及其下的所有子文件
    remove_proc_subtree(PROC_DIR_NAME, NULL);
    printk(KERN_INFO "proc_demo: /proc/%s removed\n", PROC_DIR_NAME);
}

module_init(proc_demo_init);
module_exit(proc_demo_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Test Author");
MODULE_DESCRIPTION("A /proc directory and file demo module");

1
2
3
4
5
6
7

obj-m += proc_demo.o

all:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

1
2
3
4
5
6
7
8

charles@ubuntu24:~/test-proc$ sudo insmod  proc_demo.ko
charles@ubuntu24:~/test-proc$ ls /proc/proc_demo
status
charles@ubuntu24:~/test-proc$ echo 1111 > /proc/proc_demo/status
charles@ubuntu24:~/test-proc$ dmesg -c
[176365.569965] proc_demo: Received from user space: 1111
charles@ubuntu24:~/test-proc$ cat /proc/proc_demo/status
Message from kernel: 1111

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

struct kobject {
    const char        *name;
    struct list_head    entry;
    struct kobject        *parent;   /* 决定目录层级 */
    struct kset        *kset;
    struct kobj_type    *ktype;    /* 决定属性如何读写 */
    struct kernfs_node    *sd;       /* sysfs directory entry，指向 kernfs 节点 */
    struct kref        kref;      /* 引用计数，控制生命周期 */
    ...
};

1
2
3
4
5

struct attribute {
    const char        *name;   /* 文件名 */
    umode_t            mode;    /* 权限，如 0664 */
    ...
};

1
2
3
4
5
6
7

struct kobj_type {
    void (*release)(struct kobject *kobj);      /* 引用计数归零时释放 */
    const struct sysfs_ops *sysfs_ops;          /* show/store 分发入口 */
    struct attribute **default_attrs;
    const struct attribute_group **default_groups;
    ...
};

1
2
3
4
5
6
7

struct kobj_attribute {
    struct attribute attr;
    ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr,
            char *buf);
    ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr,
             const char *buf, size_t count);
};

1
2
3
4
5
6

#define __ATTR(_name, _mode, _show, _store) {                \
    .attr = {.name = __stringify(_name),                \
         .mode = VERIFY_OCTAL_PERMISSIONS(_mode) },        \
    .show    = _show,                        \
    .store    = _store,                        \
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

用户态:   cat /sys/kernel/xxx/foo
                │
           VFS read()
                │
          kernfs 文件操作
                │
   kobj_type->sysfs_ops->show()
                │
     kobj_attribute->show()   ← 你写的函数
                │
        sprintf(buf, "%d\n", foo)

 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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kobject.h>
#include <linux/sysfs.h>
#include <linux/string.h>

/* 被 sysfs 文件读写的内核变量 */
static int foo;

/* cat 文件时被调用 */
static ssize_t foo_show(struct kobject *kobj, struct kobj_attribute *attr,
            char *buf)
{
    return sprintf(buf, "%d\n", foo);
}

/* echo > 文件时被调用 */
static ssize_t foo_store(struct kobject *kobj, struct kobj_attribute *attr,
             const char *buf, size_t count)
{
    int ret = kstrtoint(buf, 10, &foo);

    if (ret < 0)
        return ret;
    return count;   /* 必须返回已消费的字节数 */
}

/* 定义属性：0664 -> 允许 owner/group 写，但不允许 world-writable,
“world-writable” 在 Linux 权限语境下，特指文件对“其他用户（Others）”拥有写权限。
6 (owner) = 读(4) + 写(2) = 可读可写
6 (group) = 读(4) + 写(2) = 可读可写
4 (others) = 只读(4) */
static struct kobj_attribute foo_attribute =
    __ATTR(foo, 0664, foo_show, foo_store);

static struct attribute *attrs[] = {
    &foo_attribute.attr,
    NULL,    /* 必须以 NULL 结尾 */
};

static struct attribute_group attr_group = {
    .attrs = attrs,
};

static struct kobject *demo_kobj;

static int __init sysfs_demo_init(void)
{
    int ret;

    /* 在 /sys/kernel/ 下创建 sysfs_demo 目录 */
    demo_kobj = kobject_create_and_add("sysfs_demo", kernel_kobj);
    if (!demo_kobj)
        return -ENOMEM;

    /* 在该目录下创建属性文件 */
    ret = sysfs_create_group(demo_kobj, &attr_group);
    if (ret)
        kobject_put(demo_kobj);

    pr_info("sysfs_demo: loaded, see /sys/kernel/sysfs_demo/\n");
    return ret;
}

static void __exit sysfs_demo_exit(void)
{
    kobject_put(demo_kobj);   /* 引用归零后自动删除目录及文件 */
    pr_info("sysfs_demo: unloaded\n");
}

module_init(sysfs_demo_init);
module_exit(sysfs_demo_exit);

MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("your name");
MODULE_DESCRIPTION("A minimal sysfs demo module");

1
2
3
4
5
6
7
8
9

obj-m += sysfs_demo.o

KDIR ?= /lib/modules/$(shell uname -r)/build

all:
    $(MAKE) -C $(KDIR) M=$(PWD) modules

clean:
    $(MAKE) -C $(KDIR) M=$(PWD) clean

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 1. 编译（需要先安装对应内核头文件/源码）
make

# 2. 加载模块
sudo insmod sysfs_demo.ko
dmesg | tail            # 应看到 "sysfs_demo: loaded ..."

# 3. 查看目录与文件
ls -l /sys/kernel/sysfs_demo/
# -rw-rw-r-- 1 root root 4096 ... foo

# 4. 读值（默认 0）
cat /sys/kernel/sysfs_demo/foo
# 0

# 5. 写值
echo 42 | sudo tee /sys/kernel/sysfs_demo/foo
cat /sys/kernel/sysfs_demo/foo
# 42

# 6. 卸载
sudo rmmod sysfs_demo
dmesg | tail            # 应看到 "sysfs_demo: unloaded"