Linux驱动开发入门：从Hello World到字符设备驱动的完整实践指南

🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度

如果你是一名嵌入式开发者，或者对操作系统底层充满好奇，那么“编写Linux驱动程序”这个念头，可能已经在你脑海中盘旋了很久。它听起来既酷又难：酷在能直接与硬件对话，掌控系统最核心的资源；难在它似乎被内核源码、复杂的API和晦涩的调试手段所包围。很多人尝试过，但往往卡在第一步：一个最简单的“Hello World”驱动都编译不通过，或者加载后导致系统崩溃。

这篇文章要解决的，正是这个“从0到1”的鸿沟。我们不会空谈内核架构的宏大叙事，而是聚焦于一个最实际的目标：让你亲手编写、编译、加载并运行一个真正可用的Linux内核模块（驱动程序的基础形态）。你会发现，驱动开发的核心门槛，往往不是算法有多难，而是一套与普通应用开发截然不同的“游戏规则”——从编译环境、代码规范到调试方法。

本文的判断是：Linux驱动开发的核心难点在于工程实践而非理论，掌握正确的环境搭建、编译框架和调试流程，比理解所有内核API更重要。我们将通过一个完整的、可复现的示例，带你走过这段旅程。读完本文，你将能清晰地回答：为什么我的驱动编译报错？Makefile到底怎么写？模块加载失败该看哪里？这些困扰新手的关键问题。

1. 这篇文章真正要解决的问题

为什么我们要学习编写Linux驱动程序？对于大多数开发者而言，直接的需求可能来自几个方面：为特定的硬件（如公司自研的传感器、采集卡）提供支持；优化现有硬件的性能；或者纯粹为了深入理解操作系统如何工作。然而，无论是哪种需求，新手面临的第一道墙往往是“环境”和“流程”。

在普通用户空间编程中，你写一个hello.c，用gcc hello.c -o hello就能运行。但在内核空间，这套行不通。你的代码将成为内核的一部分，它需要：

1. 使用内核头文件，而不是标准的C库。
2. 遵循内核的编码规范，比如函数命名、内存管理。
3. 通过特定的构建系统（Kbuild）编译，而不是简单的gcc。
4. 以特权方式加载到运行中的内核，而不是作为一个独立进程启动。
5. 输出信息需要用到内核的日志系统，而不是printf。

网络上很多教程只给出代码片段，却忽略了构建环境和Makefile这个最关键的“脚手架”。这导致读者照抄代码后，面对满屏的编译错误束手无策。搜索“make: *** [makefile:114: yay] error 1”这类错误的人，很多正困于此。

因此，本文的核心就是打通从代码到可运行内核模块的完整实践链路。我们将从一个最简单的字符设备驱动示例开始，详细拆解每一个步骤背后的“为什么”，并重点讲解那些容易导致失败的细节，比如内核版本匹配、Makefile的编写、以及加载卸载时的权限问题。

2. 基础概念与核心原理

在动手之前，我们需要统一几个关键概念，这能帮你建立正确的心理模型。

内核模块 vs. 驱动程序

• 内核模块：一种可以动态加载到Linux内核中的代码块。它扩展了内核的功能，但并非一定是驱动。比如，一个实现新加密算法的模块也是内核模块。
• 驱动程序：一种特殊的内核模块，专门负责管理特定的硬件设备（或虚拟设备），充当硬件与操作系统其他部分（如文件系统、网络协议栈）之间的翻译官。简单说：所有的驱动程序都是内核模块，但并非所有的内核模块都是驱动程序。我们第一步编写的，就是一个最简单的内核模块，它是驱动程序的雏形。

用户空间 vs. 内核空间这是Linux系统最重要的安全与隔离设计。

• 用户空间：普通应用程序（如浏览器、文本编辑器）运行的地方。它们只能访问受限的内存和CPU指令，如果试图非法访问硬件或内核内存，会被操作系统强制终止（Segmentation Fault）。
• 内核空间：操作系统核心代码（包括驱动程序）运行的地方。拥有最高的特权级别，可以直接访问所有硬件、内存和CPU特权指令。 驱动程序运行在内核空间，这意味着你写的代码一旦出错（如空指针解引用），很可能导致整个系统崩溃（Kernel Panic），而不仅仅是程序崩溃。这就是驱动开发需要格外谨慎的原因。

模块的加载与卸载

• 加载：使用insmod（或modprobe）命令，将编译好的.ko（Kernel Object）文件插入到运行中的内核。
• 卸载：使用rmmod命令，将模块从内核中移除。 动态加载/卸载的能力是内核模块最大的优势，允许我们在不重启系统的情况下添加或移除功能。

关键数据结构：file_operations对于字符设备驱动（也是最常见、最基础的驱动类型）而言，file_operations结构体是灵魂。它定义了一系列函数指针（如open,read,write,release等），将用户空间发起的系统调用（如open(“/dev/mydevice”, O_RDWR)）映射到你驱动中具体的处理函数。你可以把它理解为驱动提供给外界的“接口菜单”。

理解了这些，我们就知道目标了：编写一个内核模块，实现一个file_operations结构体，编译成.ko文件，然后加载它，让用户程序可以通过文件操作接口与之交互。

3. 环境准备与前置条件

工欲善其事，必先利其器。驱动开发对环境有明确要求，请严格按照以下步骤准备。

3.1 操作系统与内核版本

• 操作系统：推荐使用Ubuntu LTS版本（如20.04, 22.04）或CentOS/RHEL。本文示例基于Ubuntu，但原理通用。
• 内核版本：至关重要！你编译模块所用的内核头文件或源码版本，必须与当前运行的内核版本完全一致。否则模块无法加载。 查看当前内核版本：

  uname -r

  输出类似：5.15.0-91-generic。请记下这个完整字符串。

3.2 安装必要的开发工具和内核头文件你需要编译器和内核构建环境。

# 对于 Ubuntu/Debian 系统 sudo apt update sudo apt install build-essential # 安装gcc, make等基础工具 sudo apt install linux-headers-$(uname -r) # 安装与当前运行内核匹配的头文件 # 对于 RHEL/CentOS/Fedora 系统 sudo yum groupinstall "Development Tools" sudo yum install kernel-devel-$(uname -r)

linux-headers-$(uname -r)这个包提供了编译模块所需的内核头文件和构建框架，是成功编译的关键。安装后，头文件通常位于/lib/modules/$(uname -r)/build目录，这是一个指向内核源码配置的符号链接。

3.3 准备一个安全的测试环境强烈建议在虚拟机（如VirtualBox, VMware）中进行驱动开发实验。因为一个有bug的驱动可能导致宿主机系统崩溃。虚拟机提供了完美的隔离环境，你可以随意重启而不影响主机。

3.4 验证环境创建一个临时目录作为我们的工作空间，并验证编译器。

mkdir ~/driver_lab && cd ~/driver_lab gcc --version make --version

确保两者都能正常输出版本信息。

4. 第一个内核模块：Hello World

我们从最经典的“Hello World”开始。这个模块不控制任何硬件，仅仅在加载和卸载时在内核日志中打印信息。它的目标是验证整个编译和加载流程是通的。

4.1 编写模块源代码hello.c

// hello.c - 一个最简单的Linux内核模块 #include <linux/init.h> // 包含模块初始化和清理函数的宏 #include <linux/module.h> // 包含内核模块相关的核心宏和函数 #include <linux/kernel.h> // 包含内核打印函数 printk 等 // 模块许可证声明（必须） MODULE_LICENSE("GPL"); // 模块作者声明（可选） MODULE_AUTHOR("Your Name"); // 模块描述（可选） MODULE_DESCRIPTION("A simple Hello World Linux kernel module"); // 模块加载时执行的函数 static int __init hello_init(void) { // printk 是内核中的“printf”，KERN_INFO 是日志级别 printk(KERN_INFO "Hello, World! Kernel module loaded.\n"); return 0; // 返回0表示初始化成功 } // 模块卸载时执行的函数 static void __exit hello_exit(void) { printk(KERN_INFO "Goodbye, World! Kernel module unloaded.\n"); } // 注册模块的入口和出口函数 module_init(hello_init); module_exit(hello_exit);

代码解读：

• #include <linux/...>：引入内核头文件，而不是<stdio.h>。
• MODULE_LICENSE(“GPL”)：必须声明，否则加载模块时会收到内核被“污染”的警告，甚至某些内核功能不可用。
• __init和__exit：宏定义，提示编译器将这些函数放到特定的内存段，初始化后可以释放其内存。
• printk：内核日志输出函数。KERN_INFO定义日志级别。这些信息不会打印到终端，而是输出到内核环形缓冲区。
• module_init和module_exit：宏，告诉内核哪个函数是加载入口，哪个是卸载出口。

4.2 编写构建文件Makefile这是最关键且最容易出错的一步。驱动模块使用内核的Kbuild系统编译，Makefile的写法与普通应用程序不同。

# 指向当前运行内核的构建目录 KDIR := /lib/modules/$(shell uname -r)/build # 当前模块源码目录 PWD := $(shell pwd) # 指定要构建的模块目标文件（.o文件会编译成.ko） obj-m := hello.o # 默认构建目标 all: $(MAKE) -C $(KDIR) M=$(PWD) modules # 清理构建产物 clean: $(MAKE) -C $(KDIR) M=$(PWD) clean

Makefile解读：

• obj-m := hello.o：告诉Kbuild系统，我们要构建一个名为hello.ko的模块，它由hello.o生成（源文件是hello.c）。
• $(MAKE) -C $(KDIR) M=$(PWD) modules：这是核心命令。
  • -C $(KDIR)：改变目录到内核构建目录（即我们安装的linux-headers所在位置）。
  • M=$(PWD)：告诉内核构建系统，模块的源代码位于当前目录$(PWD)。
  • modules：执行内核构建系统中构建外部模块的目标。
• 这个Makefile的作用是“调用”内核的构建系统来为我们编译模块，而不是自己定义编译规则。

4.3 编译模块在hello.c和Makefile所在的目录执行：

make

如果一切顺利，你将看到类似以下的输出，并生成多个文件，其中最重要的是hello.ko。

make -C /lib/modules/5.15.0-91-generic/build M=/home/yourname/driver_lab modules make[1]: Entering directory '/usr/src/linux-headers-5.15.0-91-generic' CC [M] /home/yourname/driver_lab/hello.o MODPOST /home/yourname/driver_lab/Module.symvers CC [M] /home/yourname/driver_lab/hello.mod.o LD [M] /home/yourname/driver_lab/hello.ko BTF [M] /home/yourname/driver_lab/hello.ko make[1]: Leaving directory '/usr/src/linux-headers-5.15.0-91-generic’

关键产出：hello.ko就是我们编译好的内核模块文件。

5. 加载、测试与卸载模块

模块编译成功只是第一步，让它在内核中运行起来才是真正的考验。

5.1 加载模块加载模块需要root权限。

sudo insmod hello.ko

命令执行后看似没有输出，这很正常，因为printk的信息输出到了内核日志。

5.2 查看模块加载信息使用dmesg命令查看内核环形缓冲区的最新消息。dmesg输出可能很多，我们用tail查看最后几行。

sudo dmesg | tail -5

你应该能看到类似这样的输出：

[ 1234.567890] Hello, World! Kernel module loaded.

这证明我们的hello_init函数被成功调用，模块已加载到内核。

5.3 检查模块列表使用lsmod命令可以查看当前已加载的所有模块，并确认我们的模块在其中。

lsmod | grep hello

输出应包含一行关于hello模块的信息，显示其被使用次数和依赖关系。

5.4 卸载模块

sudo rmmod hello

注意，rmmod后面跟的是模块名（即hello），而不是文件名hello.ko。再次查看内核日志：

sudo dmesg | tail -5

输出中应该新增了一行：

[ 1234.654321] Goodbye, World! Kernel module unloaded.

5.5 清理编译文件测试完成后，可以运行make clean来清理中间文件，只保留源代码。

make clean

至此，你已经完成了第一个内核模块的完整生命周期：编码 -> 编译 -> 加载 -> 验证 -> 卸载。这个流程是所有驱动开发的基石。

6. 进阶：创建一个简单的字符设备驱动

“Hello World”模块证明了环境是通的。现在我们来创建一个更有实际意义的驱动：一个简单的字符设备驱动。用户程序可以像读写文件一样（通过open,read,write,close系统调用）与这个驱动交互。

6.1 设计目标我们将创建一个名为mychardev的字符设备。它内部维护一段内核内存作为缓冲区。用户程序可以：

• 写入数据到该缓冲区。
• 从该缓冲区读取数据。
• 这是一个典型的“内存设备”模型，是理解驱动与用户空间数据交换的绝佳示例。

6.2 编写驱动源代码chardev.c

// chardev.c - 一个简单的字符设备驱动示例 #include <linux/module.h> #include <linux/kernel.h> #include <linux/fs.h> // 包含 file_operations 结构体 #include <linux/cdev.h> // 字符设备结构体 cdev #include <linux/slab.h> // 内核内存分配函数 kmalloc, kfree #include <linux/uaccess.h> // 用户/内核空间数据拷贝函数 copy_to_user, copy_from_user #define DEVICE_NAME "mychardev" #define BUFFER_SIZE 1024 // 设备结构体，封装设备相关的所有信息 struct mychardev_dev { struct cdev cdev; // 内核的字符设备结构 char *data_buffer; // 设备的数据缓冲区 unsigned buffer_size; // 缓冲区大小 }; static int major_num = 0; // 主设备号，0表示动态分配 static struct mychardev_dev *mychardev_device; // 当用户程序打开设备文件时调用 static int chardev_open(struct inode *inode, struct file *filp) { struct mychardev_dev *dev; // 通过 inode 获取我们自己的设备结构体 dev = container_of(inode->i_cdev, struct mychardev_dev, cdev); // 将设备结构体指针保存到 file 结构的私有数据区，便于其他操作函数使用 filp->private_data = dev; printk(KERN_INFO "mychardev: Device opened\n"); return 0; } // 当用户程序关闭设备文件时调用 static int chardev_release(struct inode *inode, struct file *filp) { printk(KERN_INFO "mychardev: Device closed\n"); return 0; } // 当用户程序从设备读取数据时调用 static ssize_t chardev_read(struct file *filp, char __user *user_buf, size_t count, loff_t *offset) { struct mychardev_dev *dev = filp->private_data; ssize_t bytes_to_read; size_t available; // 计算从当前偏移量开始，还有多少数据可读 available = dev->buffer_size - *offset; bytes_to_read = (count < available) ? count : available; if (bytes_to_read == 0) { printk(KERN_INFO "mychardev: No more data to read\n"); return 0; // 到达文件末尾 } // 将内核缓冲区数据拷贝到用户空间缓冲区 if (copy_to_user(user_buf, dev->data_buffer + *offset, bytes_to_read)) { return -EFAULT; // 拷贝失败，返回错误码 } // 更新偏移量 *offset += bytes_to_read; printk(KERN_INFO "mychardev: Read %zd bytes from device\n", bytes_to_read); return bytes_to_read; // 返回实际读取的字节数 } // 当用户程序向设备写入数据时调用 static ssize_t chardev_write(struct file *filp, const char __user *user_buf, size_t count, loff_t *offset) { struct mychardev_dev *dev = filp->private_data; ssize_t bytes_to_write; size_t available; // 计算从当前偏移量开始，还有多少空间可写 available = dev->buffer_size - *offset; bytes_to_write = (count < available) ? count : available; if (bytes_to_write == 0) { printk(KERN_INFO "mychardev: No space left to write\n"); return -ENOSPC; // 设备空间不足 } // 将用户空间缓冲区数据拷贝到内核缓冲区 if (copy_from_user(dev->data_buffer + *offset, user_buf, bytes_to_write)) { return -EFAULT; // 拷贝失败，返回错误码 } // 更新偏移量 *offset += bytes_to_write; printk(KERN_INFO "mychardev: Wrote %zd bytes to device\n", bytes_to_write); return bytes_to_write; // 返回实际写入的字节数 } // 定义文件操作函数集 static struct file_operations chardev_fops = { .owner = THIS_MODULE, .open = chardev_open, .release = chardev_release, .read = chardev_read, .write = chardev_write, // 注意：我们没有实现 .llseek，默认是逐字节偏移，类似内存 }; // 模块初始化函数 static int __init chardev_init(void) { dev_t dev_num; int ret; // 1. 动态分配一个主设备号（或指定一个） ret = alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME); if (ret < 0) { printk(KERN_ERR "mychardev: Failed to allocate device number\n"); return ret; } major_num = MAJOR(dev_num); // 提取主设备号 printk(KERN_INFO "mychardev: Allocated major number %d\n", major_num); // 2. 为设备结构体分配内存 mychardev_device = kmalloc(sizeof(struct mychardev_dev), GFP_KERNEL); if (!mychardev_device) { ret = -ENOMEM; goto fail_alloc_dev; } memset(mychardev_device, 0, sizeof(struct mychardev_dev)); // 3. 为数据缓冲区分配内存 mychardev_device->data_buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL); if (!mychardev_device->data_buffer) { ret = -ENOMEM; goto fail_alloc_buffer; } memset(mychardev_device->data_buffer, 0, BUFFER_SIZE); mychardev_device->buffer_size = BUFFER_SIZE; // 4. 初始化并添加字符设备结构到内核 cdev_init(&mychardev_device->cdev, &chardev_fops); mychardev_device->cdev.owner = THIS_MODULE; ret = cdev_add(&mychardev_device->cdev, dev_num, 1); if (ret) { printk(KERN_ERR "mychardev: Failed to add cdev\n"); goto fail_cdev_add; } printk(KERN_INFO "mychardev: Character device driver loaded successfully.\n"); printk(KERN_INFO "mychardev: Create a device file with: sudo mknod /dev/%s c %d 0\n", DEVICE_NAME, major_num); return 0; // 初始化成功 // 错误处理：按初始化相反的顺序释放资源 fail_cdev_add: kfree(mychardev_device->data_buffer); fail_alloc_buffer: kfree(mychardev_device); fail_alloc_dev: unregister_chrdev_region(dev_num, 1); return ret; } // 模块清理函数 static void __exit chardev_exit(void) { dev_t dev_num = MKDEV(major_num, 0); // 根据主设备号生成设备号 // 1. 从内核移除字符设备 if (mychardev_device) { cdev_del(&mychardev_device->cdev); } // 2. 释放缓冲区内存 if (mychardev_device && mychardev_device->data_buffer) { kfree(mychardev_device->data_buffer); } // 3. 释放设备结构体内存 if (mychardev_device) { kfree(mychardev_device); } // 4. 释放设备号 unregister_chrdev_region(dev_num, 1); printk(KERN_INFO "mychardev: Character device driver unloaded.\n"); } module_init(chardev_init); module_exit(chardev_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Your Name"); MODULE_DESCRIPTION("A simple character device driver example");

这个代码较长，但结构清晰，是字符设备驱动的标准模板。核心是实现了file_operations中的几个关键操作。

6.3 更新 Makefile修改Makefile，将构建目标改为chardev.o。

KDIR := /lib/modules/$(shell uname -r)/build PWD := $(shell pwd) obj-m := chardev.o # 修改这一行 all: $(MAKE) -C $(KDIR) M=$(PWD) modules clean: $(MAKE) -C $(KDIR) M=$(PWD) clean

6.4 编译与加载

make sudo insmod chardev.ko

加载后，查看内核日志获取动态分配的主设备号：

sudo dmesg | tail -5

输出中会有一行类似：mychardev: Allocated major number 511。记下这个数字（例如511）。

6.5 创建设备文件驱动加载后，内核中有了这个设备，但用户空间还需要一个“文件”作为交互接口。这就是设备文件，通常位于/dev目录下。 使用mknod命令创建设备文件，需要主设备号和次设备号（这里次设备号用0）。

# 假设主设备号是 511 sudo mknod /dev/mychardev c 511 0 # 设置权限，让普通用户可读写 sudo chmod 666 /dev/mychardev

• c表示创建的是字符设备文件。
• 511是主设备号（从dmesg中获取）。
• 0是次设备号。

6.6 测试驱动现在，我们可以用普通的命令行工具来测试这个驱动了。

测试写入：

echo "Hello from userspace!" > /dev/mychardev

测试读取：

cat /dev/mychardev

你应该能看到输出的“Hello from userspace!”。再次读取，因为偏移量已经移动，会返回空（或之前缓冲区剩余内容）。

查看内核日志，观察驱动的行为：

sudo dmesg | tail -10

你会看到驱动打印的“Device opened”, “Wrote … bytes”, “Device closed”, “Device opened”, “Read … bytes”等信息。

6.7 卸载驱动测试完成后，按顺序清理：

sudo rmmod chardev sudo rm /dev/mychardev # 删除设备文件

7. 常见问题与排查思路

在驱动开发中，失败是常态。以下是新手最容易遇到的问题及解决方法。

8. 最佳实践与工程建议

当你掌握了基础流程后，以下建议能帮助你写出更健壮、更专业的驱动代码。

8.1 内存管理

• 使用内核内存分配函数：kmalloc/kfree用于一般内存，vmalloc用于大块虚拟连续内存。永远不要使用用户空间的malloc/free。
• 检查分配返回值：内核内存紧张时分配可能失败，必须检查kmalloc返回是否为NULL。
• 初始化内存：使用memset或kzalloc（分配并清零）来初始化分配的内存，避免野值。

8.2 错误处理

• 资源申请顺序与释放顺序：在初始化函数中，资源申请（如分配内存、注册设备号）应有一个清晰的顺序。在错误处理 (goto标签) 和退出函数中，必须以相反的顺序释放资源，防止资源泄漏。
• 使用goto进行错误处理：在内核编程中，使用goto跳转到统一的错误处理段是常见且受认可的模式，它能使代码更清晰，如上文chardev_init所示。

8.3 并发控制

• 驱动可能是多线程的：多个用户进程可能同时打开同一个设备文件并进行读写。如果驱动使用共享数据（如全局缓冲区、设备状态），必须考虑并发访问。
• 使用内核同步机制：如信号量 (semaphore)、互斥锁 (mutex)、自旋锁 (spinlock) 来保护临界区。对于我们的简单示例，可以添加一个struct mutex lock;到设备结构体，在open时初始化，在read/write中加锁解锁。

8.4 代码规范与可读性

• 遵循内核编码风格：Linux内核有严格的代码风格规范（如缩进用8个空格、括号位置等）。使用scripts/checkpatch.pl工具可以检查代码风格。保持风格一致有助于代码审查和维护。
• 添加有意义的日志：printk是重要的调试工具，但生产代码中应减少KERN_INFO级别的日志，避免刷屏。使用KERN_DEBUG并可通过内核参数动态开启。

8.5 安全性

• 永远不要信任用户输入：用户空间传递下来的指针、长度参数都可能是恶意的。在read/write/ioctl等函数中，必须验证参数的有效性（如缓冲区范围、指针是否可读/可写）。
• 使用安全的拷贝函数：坚持使用copy_from_user和copy_to_user，它们会进行必要的安全检查。

8.6 调试技巧

• printk是最好朋友：在不同位置添加不同级别的printk，是追踪执行流程和变量值的最简单方法。
• 使用/proc或sysfs：对于复杂的驱动，可以通过/proc或sysfs文件系统在运行时导出内部状态信息，方便调试。
• 使用strace和ltrace：在用户空间，使用strace跟踪进程的系统调用，使用ltrace跟踪库函数调用，可以帮助判断问题是出在用户程序还是驱动。

从“Hello World”模块到功能完整的字符设备驱动，你已经走过了Linux驱动开发中最具挑战性的入门阶段。这个过程的核心收获不是记住了多少个API，而是理解了内核模块的生命周期管理、用户与内核空间的边界、以及通过文件接口与硬件交互的抽象模型。

驱动开发的下一步，可以朝着几个方向深入：

1. 完善字符设备驱动：实现llseek,ioctl（用于设备控制命令）,mmap（内存映射）等更多文件操作。
2. 探索其他设备类型：如块设备驱动（用于磁盘）、网络设备驱动（用于网卡）。它们的架构和API与字符设备不同。
3. 集成真实硬件：学习如何通过CPU的I/O端口或内存映射I/O（MMIO）来读写硬件寄存器，这是驱动与物理设备对话的基础。
4. 研究内核子系统：如中断处理、工作队列、定时器、DMA等，这些是编写高性能、异步驱动所必需的。

建议将本文的示例代码作为你的“脚手架”，在虚拟机中反复练习、修改和调试。每一次编译错误和内核崩溃（panic）都是加深理解的契机。当你能够从容地让一个自定义的驱动响应read/write时，你就已经打开了Linux内核世界的一扇大门。

🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度