Linux(28)-sysfs层次分析

hhwyqwqhhwy2026-08-20 19:13

Linux(28)-sysfs层次分析

宏观分析

sysfs 是一个纯粹基于 RAM 的内存文件系统。它将内核内存中抽象的设备模型数据结构，以直观的树状目录形式呈现给用户态。 根目录 /sys 下的各个子目录，分别映射了内核设备模型中的不同维度：

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

  • devices:它完全按照硬件真实的物理连接级联关系（如：CPU/根复合体 ➔ PCI 桥 ➔ 控制器 ➔ 设备）构建。sysfs 中其他目录下的硬件节点，绝大多数只是指向该目录具体节点的符号链接.

  • bus/（总线视角）:按照总线协议划分子目录（如 pci、usb、i2c、platform）。每个总线目录下固定包含两个子目录

    • devices/：挂载在该总线上的所有设备（软链接至 /sys/devices/）

    • drivers/：在当前总线上注册的所有驱动程序。

  • class/（功能类视角）:纯粹按设备的功能进行分类,如 net 网卡、sound 声卡、input 输入设备、block 块设备等

  • dev/（设备号快捷索引）:包含 block/ 与 char/ 两个子目录，内部以 主设备号:次设备号（例如 8:0）命名的软链接快捷定位设备

  • module/（内核模块视图）:展示系统中已加载的每一个内核模块（.ko）及其导出的参数（/sys/module/<mod_name>/parameters/）与运行状态。

  • firmware/（固件与引导视图）:展示系统固件暴露的信息。其中最关键的节点是 /sys/firmware/devicetree/base/，它是 Bootloader 在启动阶段传入内核的设备树（Device Tree）二进制镜像在 sysfs 中的完全解包映射。

宏观例子

1.设备树（DTS）定义

以一个常见的 I2C 总线温度传感器（如 TMP102 / MPU6050 类型） 为例，拆解设备树节点从系统启动到最终被应用层使用的全过程。

复制代码 
&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 */
    };
};

2.内核启动与驱动加载过程

当内核启动并加载了对应的驱动程序（tmp102.ko）后，系统会自动在 sysfs 和 /dev 中进行多维度的映射建立

/sys/devices/:内核根据硬件真实的连接关系建立目录，这是传感器在系统中的唯一真实节点：

复制代码 
/sys/devices/platform/soc/30a20000.i2c/i2c-0/0-0048/
  • 含义：SOC 平台 I2C 控制器（地址 0x30a20000） I2C 总线 0 地址为 0x48 的从设备。

/sys/bus/:传感器连接在 I2C 总线上，内核在 i2c 总线目录下生成软链接：

复制代码 
/sys/bus/i2c/devices/0-0048 -> ../../../devices/platform/soc/30a20000.i2c/i2c-0/0-0048
/sys/bus/i2c/drivers/tmp102/
  • 含义：devices/ 下通过软链接映射该物理设备，drivers/tmp102/ 目录下展示匹配成功的驱动信息。

3.功能分类层：/sys/class/

驱动在 probe() 函数中将其注册为"硬件监控类（hwmon）"或"工业 IO 类（iio）"，屏蔽总线细节：

复制代码 
/sys/class/hwmon/hwmon0 -> ../../devices/platform/soc/30a20000.i2c/i2c-0/0-0048/hwmon/hwmon0
  • 含义：无论设备挂载在 I2C、SPI 还是 PCIe 上，应用层只需去 /sys/class/hwmon/寻找温度传感器。

4.设备号索引层：/sys/dev/

驱动程序为传感器申请了字符设备号（假设主设备号 241，次设备号 0）：

复制代码 
/sys/dev/char/241:0 -> ../../devices/platform/soc/30a20000.i2c/i2c-0/0-0048/hwmon/hwmon0
  • 含义：通过设备号快速查找和定位设备对应的物理节点。

**5.模块视图层：/sys/module/**加载了驱动模块 tmp102.ko 后：

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

6.应用层调用

设备加载完成后，应用层根据业务场景，通过 sysfs 或 字符设备节点 /dev 两种主要方式读写数据。

  • 方式 1：通过 sysfs 属性读取（低频控制 / 查看状态）

    • 传感器驱动在 /sys/class/hwmon/hwmon0/ 目录下创建了 temp1_input 文件（对应 struct attribute 的 show() 回调）： Shell 命令行直接读取

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

cpp 复制代码 
#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 字符设备节点：
cpp 复制代码 
#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 下的目录创建。

cpp 复制代码 
#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 函数处理，实现代码复用。

cpp 复制代码 
#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");

static struct kset *my_kset;
static struct kobject *kobj1;
static struct kobject *kobj2;

static int __init traverse_demo_init(void)
{
    int ret;
    struct kobject *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");
    return 0;

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

static void __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. 定义数据结构与属性文件
cpp 复制代码 
#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() 回调
cpp 复制代码 
/* 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,
};

brightness_attr 目前只是被‌定义和初始化‌了，但还没有真正"生效"或"注册"到 sysfs 中。

要让它真正出现在 /sys/.../brightness 并响应用户操作，你需要在模块初始化函数（__init）中将其添加到对应的 kobject 上。

以下是 brightness_attr 被用到的具体位置和方式：

1. 在模块初始化时注册（关键步骤）

你需要在 kobject 创建成功后，调用 sysfs_create_file() 将这个属性文件绑定到该 kobject 代表的目录上。

假设你有一个全局的 struct led_device *my_led_dev，并且它的 kobj 已经通过 kobject_init_and_add 创建好了目录（例如 /sys/demo_led），代码如下：

cpp 复制代码 
static struct led_device *my_led_dev;

static int __init led_demo_init(void)
{
    int ret;

    // 1. 分配内存
    my_led_dev = kzalloc(sizeof(*my_led_dev), GFP_KERNEL);
    if (!my_led_dev)
        return -ENOMEM;

    // 2. 初始化 kobject 并添加到 sysfs (创建 /sys/demo_led 目录)
    // 注意：这里需要指定 kobj_type，其中包含 sysfs_ops
    ret = kobject_init_and_add(&my_led_dev->kobj, &led_ktype, NULL, "demo_led");
    if (ret) {
        kfree(my_led_dev);
        return ret;
    }

    // 3. 【这里是用到 brightness_attr 的地方】
    // 将 brightness_attr 中的 attribute 成员注册到 kobject 下
    // 这会在 /sys/demo_led/ 下创建一个名为 "brightness" 的文件
    ret = sysfs_create_file(&my_led_dev->kobj, &brightness_attr.attr);
    if (ret) {
        kobject_put(&my_led_dev->kobj);
        kfree(my_led_dev);
        return ret;
    }

    pr_info("LED demo module loaded\n");
    return 0;
}

2. 在模块退出时卸载

为了保持内核整洁，防止内存泄漏或悬空指针，在模块卸载时必须移除该属性文件。

cpp 复制代码 
static void __exit led_demo_exit(void)
{
    if (my_led_dev) {
        // 【这里也是用到 brightness_attr 的地方】
        // 从 sysfs 中移除 brightness 文件
        sysfs_remove_file(&my_led_dev->kobj, &brightness_attr.attr);
        
        // 释放 kobject 引用
        kobject_put(&my_led_dev->kobj);
        
        // 释放内存
        kfree(my_led_dev);
    }
    pr_info("LED demo module unloaded\n");
}

3. 底层回调机制中的间接使用

虽然代码中没有直接写 brightness_attr.show()，但当用户空间执行操作时，内核会间接使用它：

  1. ‌用户读取时 ‌ (cat /sys/demo_led/brightness)：

    • VFS 层找到该文件对应的 attribute 结构体（即 brightness_attr.attr）。
    • 通过之前定义的 led_ktype 中的 sysfs_ops (led_attr_show) 进行分发。
    • led_attr_show 内部通过 container_of 找到 brightness_attr，从而调用你写的 led_brightness_show。

  2. ‌用户写入时 ‌ (echo 128 > ...)：

    • 同理，内核通过 led_attr_store 分发，最终调用 brightness_attr.store 指向的 led_brightness_store 函数。

总结

brightness_attr 主要在以下两个地方被显式调用：

  1. ‌**sysfs_create_file(&dev->kobj, &brightness_attr.attr)**‌：用于创建文件节点。
  2. ‌**sysfs_remove_file(&dev->kobj, &brightness_attr.attr)**‌：用于删除文件节点。

而在运行时，它的 .show 和 .store 函数指针会被内核的 sysfs 核心代码间接调用，以处理具体的读写请求。

    1. 绑定 sysfs_ops 桥接函数sysfs_ops 是连接通用 kobject 与驱动具体属性的桥梁
cpp 复制代码 
/* 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）

阅读 121

​

留言

写留言

还没有留言，来写首评

小嵌同学

赞

17

1

写留言

复制转发划线推荐写评论搜一搜

复制搜一搜

暂无评论

相关推荐
菠萝猫yena2 小时前
【git】git 命令常用组合
大数据·git·elasticsearch
Leo.yuan4 小时前
AI辅助数据分析：如何让分析效率提升85%？
大数据·人工智能
Sayai5 小时前
Elasticsearch 压测利器 esrally 从安装到跑分全流程
大数据·elasticsearch·搜索引擎
科技发布6 小时前
传播易整合商圈媒体，商场停车场灯箱广告高效落地
大数据·人工智能·媒体
MindUp6 小时前
大模型在命理排盘场景下的多平台功能对比与工程化思考
大数据·人工智能
小刘快学习6 小时前
印刷包装企业的工艺问答与报价，为什么从直连模型改成了聚合网关
大数据·人工智能
大模型探索者7 小时前
2026零售与电子商务大模型训推平台选型指南：大促高并发与极致算力降本破局
大数据·人工智能·零售
WA内核拾荒者7 小时前
WhatsApp账号运营SOP的可视化编排与流水线监控
大数据·数据库·windows
楷哥爱开发7 小时前
目标国家 IP 会影响 TikTok、Instagram 的内容分发和受众地区吗？
大数据·运维·tcp/ip
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02GitHub 镜像站点03微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新042026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？05历年考研数学一、数学二、数学三真题试卷及答案PDF06Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费07AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路08VSCode+CodeX扩展，无法启动092026年7月AI圈大地震：GPT-5.6被政府限制、Claude入驻Slack、Anthropic自研芯片10如何新建文件夹？ 电脑新建文件夹的4种方法