/sys/
├── devices/       # 核心：物理设备的真实级联拓扑树
├── bus/           # 维度一：按总线类型分类（pci, usb, i2c, platform...）
├── class/         # 维度二：按设备功能分类（net, block, sound, input...）
├── dev/           # 维度三：按设备号快速索引（char/, block/）
├── module/        # 视图四：内核已加载模块的状态与导出参数
└── firmware/      # 视图五：系统固件与设备树镜像 (devicetree/base/)

&i2c1 {
    status = "okay";
    clock-frequency = <100000>;

/* 定义 I2C1 总线下的子设备：温度传感器 */
    my_sensor: tmp102@48 {
        compatible = "ti,tmp102";      /* 核心：与内核驱动进行匹配的标识 */
        reg = <0x48>;                 /* I2C 从机设备地址 */
        interrupt-parent = <&gpio1>;  /* 中断控制器 */
        interrupts = <20 IRQ_TYPE_EDGE_FALLING>; /* 中断引脚 GPIO1_20 */
    };
};

/sys/devices/platform/soc/30a20000.i2c/i2c-0/0-0048/

/sys/bus/i2c/devices/0-0048 -> ../../../devices/platform/soc/30a20000.i2c/i2c-0/0-0048
/sys/bus/i2c/drivers/tmp102/

/sys/class/hwmon/hwmon0 -> ../../devices/platform/soc/30a20000.i2c/i2c-0/0-0048/hwmon/hwmon0

/sys/dev/char/241:0 -> ../../devices/platform/soc/30a20000.i2c/i2c-0/0-0048/hwmon/hwmon0

/sys/module/tmp102/
├── parameters/       # 模块导出参数
├── refcnt           # 引用计数
└── drivers/         # 绑定的驱动列表

$ cat /sys/class/hwmon/hwmon0/temp1_input
25000  # 代表 25.000 ℃（千分之一摄氏度单位）

#include <stdio.h>

int main() {
    FILE *fp = fopen("/sys/class/hwmon/hwmon0/temp1_input", "r");
if (!fp) return -1;

    int raw_temp = 0;
    fscanf(fp, "%d", &raw_temp);
    fclose(fp);

printf("当前温度为: %.2f ℃\n", raw_temp / 1000.0);
return 0;
}

• 方式 2：通过 /dev/ 设备节点读写（大流量数据 / 连续采样）如果驱动向系统注册了 /dev/temp_sensor0 字符设备节点：

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    // 1. 打开驱动生成的设备节点
    int fd = open("/dev/temp_sensor0", O_RDONLY);
if (fd < 0) return -1;

    // 2. 直接从设备读取原始数据流
    short raw_data = 0;
read(fd, &raw_data, sizeof(raw_data));

    close(fd);
printf("读取到的原始温度寄存器数值: 0x%04X\n", raw_data);
return 0;
}

微观分析

sysfs 严谨的树状目录，在内核 C 语言底层完全由统一设备模型的三大结构体（kobject、kset、attribute）驱动和支撑。

• kobject：目录的物理实体
  struct kobject 是 Linux 内核设备模型的基石，每个实例在 sysfs 中具象为一个目录。它通过 parent 指针构建树状层级，支撑设备拓扑；内置 struct kref 实现原子级引用计数，保障对象安全释放；其 name 字段直接决定该目录在 sysfs 中的路径名。

• kset：目录容器与热插拔事件源
  struct kset 作为逻辑容器，聚合同类 kobject（如所有 PCI 设备或所有 USB 类设备），在 sysfs 中表现为分类目录（如 /sys/bus/pci 或 /sys/class/net）。它不仅提供统一的注册/注销入口，更关键的是：当成员 kobject 动态增删时，kset 触发 uevent，向用户态广播事件，驱动 udev 自动同步 /dev/ 下的设备节点。

• attribute：目录中的文件与读写接口
  struct attribute 映射为 sysfs 目录下的单值文本文件（如 /sys/class/leds/xxx/brightness），严格遵循 One Value Per File 原则。其行为由 struct sysfs_ops 的两个回调定义：show() 将内核数据序列化为字符串供 cat 读取；store() 解析用户写入的字符串，完成参数更新或硬件控制，实现用户态与内核态的轻量交互。

微观例子

kobject 实现sysfs 的目录创建

如上图在sys 下是没办法手动创建任何文件夹因为没有权限，下面使用代码中的kobject 实现sys 下的目录创建。

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

static struct kobject *demo_kobj;
static int demo_value;

/* 读取 /sys/study_demo/value 时会进这个回调 */
static ssize_t value_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
{
return scnprintf(buf, PAGE_SIZE, "%d\n", demo_value);
}

/* 向 /sys/study_demo/value echo 123 > /sys/study_demo/value 写入数据时会进这个回调 */
static ssize_t value_store(struct kobject *kobj, struct kobj_attribute *attr,
      const char *buf, size_t count)
{
 int ret;

 ret = kstrtoint(buf, 10, &demo_value);
if (ret)
return ret;

return count;
}

/* 创建一个可读写的 sysfs 属性节点 */
static struct kobj_attribute value_attr = __ATTR(value, 0664, value_show, value_store);

static int __init kobject_demo_init(void)
{
 int ret;

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

 /* 在目录里创建 value 属性文件 */
 ret = sysfs_create_file(demo_kobj, &value_attr.attr);
if (ret) {
  kobject_put(demo_kobj);
return ret;
 }

 pr_info("kobject_demo loaded: /sys/study_demo/value\n");
return 0;
}

static void __exit kobject_demo_exit(void)
{
 /* 卸载模块前清理 sysfs 节点和 kobject */
if (demo_kobj) {
  sysfs_remove_file(demo_kobj, &value_attr.attr);
  kobject_put(demo_kobj);
 }

 pr_info("kobject_demo unloaded\n");
}

module_init(kobject_demo_init);
module_exit(kobject_demo_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Xiaoqian");
MODULE_DESCRIPTION("kobject demo for RK3568");

kset 实现目录容器

前面的 kobject 不也是可以实现多层目录结构么，kset 有什么特殊之处？

以内核设备模型中的 “网卡驱动（Network Devices）” 为例，对比单纯使用 kobject 和结合使用 kset 的区别：

如果只是使用kobject 构建目录结构

如果你想在 sysfs 中管理两张网卡 eth0 和 eth1，仅使用 kobject 时：

// 1. 手动创建一个父级目录 kobject
struct kobject *net_parent = kobject_create_and_add("net", NULL);

// 2. 创建 eth0，显式将 parent 指向 net_parent
struct kobject *eth0_obj = kobject_create_and_add("eth0", net_parent);

// 3. 创建 eth1，再次显式指定 net_parent
struct kobject *eth1_obj = kobject_create_and_add("eth1", net_parent);

目录结构结果：

/sys/net/
├── eth0
└── eth1

这种方式只是创建了一个节点，但是节点之间有什么关系并没有体现就会出现下面的问题

• 无法遍历：内核本身不知道 net_parent 下面到底有哪些子网卡，除非你在驱动里自己写套 eth0_node、eth1_node 链表来存储。
• 事件孤立：当 eth0 网线插入时，eth0_obj 无法直接通过父节点向用户态（如 NetworkManager）广播网卡状态改变的 uevent 消息。

如果用如果使用 kset 管理网卡集合：

// 1. 创建网卡子系统的 kset 容器
struct kset *net_kset = kset_create_and_add("net", NULL, NULL);

// 2. 创建 eth0 并关联到 net_kset
struct kobject *eth0_obj = kzalloc(sizeof(*eth0_obj), GFP_KERNEL);
eth0_obj->kset = net_kset; // 建立归属关系
kobject_init_and_add(eth0_obj, &net_ktype, NULL, "eth0"); // parent 传 NULL 即可

// 3. 创建 eth1 并关联到 net_kset
struct kobject *eth1_obj = kzalloc(sizeof(*eth1_obj), GFP_KERNEL);
eth1_obj->kset = net_kset;
kobject_init_and_add(eth1_obj, &net_ktype, NULL, "eth1");

目录结构结果：完全相同（/sys/net/eth0 和 /sys/net/eth1）不同的是：

• 内核内部自动将 eth0_obj 和 eth1_obj 挂载到 net_kset->list 链表上。当系统需要遍历所有网卡时，直接执行：

struct kobject *k;
list_for_each_entry(k, &net_kset->list, entry) {
    // 一键遍历获取 eth0, eth1 并进行统一操作
}

• 统一响应与广播热插拔事件（uevent）当 eth0 启动或断开时，直接调用：

kobject_uevent(eth0_obj, KOBJ_CHANGE);

• eth0_obj 会通过其所属的 net_kset 统一的 uevent_ops 机制，向用户态发送广播，促使上层网络服务（如 udevd）响应事件并自动配置 IP 地址。

• eth0 和 eth1 共享 net_kset 提供的公共 net_ktype。读取 eth0/speed 和 eth1/speed 时，内核统一调用同一套 show/store 函数处理，实现代码复用。

#include<linux/module.h>
#include<linux/kernel.h>
#include<linux/init.h>
#include<linux/kobject.h>
#include<linux/sysfs.h>
#include<linux/slab.h>
#include<linux/list.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Xiaoqian");
MODULE_DESCRIPTION("A simple kernel module demonstrating kset traversal over its kobjects");

staticstructkset *my_kset;
staticstructkobject *kobj1;
staticstructkobject *kobj2;

staticint __init traverse_demo_init(void)
{
int ret;
structkobject *entry;

/* 1. 创建顶层 kset 容器目录：/sys/my_network_kset/ */
    my_kset = kset_create_and_add("my_network_kset", NULL, NULL);
if (!my_kset)
return -ENOMEM;

/* 2. 创建并注册第一个子 kobject (eth0) */
    kobj1 = kzalloc(sizeof(*kobj1), GFP_KERNEL);
if (!kobj1) {
        ret = -ENOMEM;
goto err_kset;
    }
    kobj1->kset = my_kset; /* 绑定归属关系 */
    ret = kobject_init_and_add(kobj1, &dynamic_kobj_ktype, NULL, "eth0");
if (ret) {
        kobject_put(kobj1);
goto err_kset;
    }

/* 3. 创建并注册第二个子 kobject (eth1) */
    kobj2 = kzalloc(sizeof(*kobj2), GFP_KERNEL);
if (!kobj2) {
        ret = -ENOMEM;
goto err_kobj1;
    }
    kobj2->kset = my_kset; /* 绑定归属关系 */
    ret = kobject_init_and_add(kobj2, &dynamic_kobj_ktype, NULL, "eth1");
if (ret) {
        kobject_put(kobj2);
goto err_kobj1;
    }

/* 4. 【核心展示】：通过 kset 的内部链表遍历所有归属的 kobject */
    pr_info("--- Traversal started for kset: %s ---\n", kobject_name(&my_kset->kobj));

/* 互斥锁保护，防止链表在遍历时被动态修改 */
    spin_lock(&my_kset->list_lock);
    list_for_each_entry(entry, &my_kset->list, entry) {
        pr_info("Found kobject: %s (Path: %s)\n",
                kobject_name(entry), kobject_get_path(entry, GFP_ATOMIC));
    }
    spin_unlock(&my_kset->list_lock);

    pr_info("--- Traversal completed ---\n");
return0;

err_kobj1:
    kobject_put(kobj1);
err_kset:
    kset_unregister(my_kset);
return ret;
}

staticvoid __exit traverse_demo_exit(void)
{
/* 清理释放子 kobject 及 kset */
    kobject_put(kobj2);
    kobject_put(kobj1);
    kset_unregister(my_kset);
    pr_info("Module unloaded\n");
}

module_init(traverse_demo_init);
module_exit(traverse_demo_exit);

attribute 实现

下面以一个真实的 LED 亮度控制驱动 为例，拆解 struct attribute、struct sysfs_ops 以及 show() / store() 回调在用户态与内核态交互时的具体工作流程。

1. 定义数据结构与属性文件

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

/* 定义设备私有数据结构体 */
struct led_device {
    int brightness;        /* 记录当前 LED 亮度值 (0-255) */
    struct kobject kobj;   /* 内嵌 kobject 关联 sysfs 目录 */
};

/* 自定义属性结构体，继承标准的 struct attribute */
struct led_attribute {
    struct attribute attr;
    ssize_t (*show)(struct led_device *dev, char *buf);
    ssize_t (*store)(struct led_device *dev, const char *buf, size_t count);
};

• 2.实现 show() 与 store() 回调

/* 1. show 回调：响应用户态 cat /sys/demo_led/brightness */
static ssize_t led_brightness_show(struct led_device *dev, char *buf)
{
    // 将内核中的 brightness 数值序列化为文本字符串输出
return sysfs_emit(buf, "%d\n", dev->brightness);
}

/* 2. store 回调：响应用户态 echo 128 > /sys/demo_led/brightness */
static ssize_t led_brightness_store(struct led_device *dev, const char *buf, size_t count)
{
    int val, ret;

    // 解析用户态传入的字符串为整数
    ret = kstrtoint(buf, 10, &val);
if (ret < 0)
return ret;

    // 参数范围检查
if (val < 0 || val > 255)
return -EINVAL;

    // 更新内核状态并模拟控制硬件
    dev->brightness = val;
    pr_info("[LED Driver] Hardware PWM updated to brightness: %d\n", val);

return count; // 返回写入的字节数，告知内核写入成功
}

/* 实例化属性文件：生成名为 "brightness" 的属性，权限为 0664 (可读写) */
static struct led_attribute brightness_attr = {
    .attr = {
        .name = "brightness",
        .mode = 0664,
    },
    .show = led_brightness_show,
    .store = led_brightness_store,
};

1. 绑定 sysfs_ops 桥接函数sysfs_ops 是连接通用 kobject 与驱动具体属性的桥梁

/* sysfs 操作接口的通用分发函数 */
static ssize_t led_attr_show(struct kobject *kobj, struct attribute *attr, char *buf)
{
    // 通过 container_of 获取外层结构体指针
    struct led_device *dev = container_of(kobj, struct led_device, kobj);
    struct led_attribute *led_attr = container_of(attr, struct led_attribute, attr);

if (led_attr->show)
return led_attr->show(dev, buf);
return -EIO;
}

static ssize_t led_attr_store(struct kobject *kobj, struct attribute *attr, const char *buf, size_t count)
{
    struct led_device *dev = container_of(kobj, struct led_device, kobj);
    struct led_attribute *led_attr = container_of(attr, struct led_attribute, attr);

if (led_attr->store)
return led_attr->store(dev, buf, count);
return -EIO;
}

/* 定义系统的 sysfs_ops */
static const struct sysfs_ops led_sysfs_ops = {
    .show = led_attr_show,
    .store = led_attr_store,
};

static struct kobj_type led_ktype = {
    .sysfs_ops = &led_sysfs_ops,
};

执行交互过程分析

场景 1：读取属性（用户态执行 cat /sys/demo_led/brightness）

场景 2：写入控制（用户态执行 echo 200 > /sys/demo_led/brightness）