嵌入式 Linux 与 RTOS / 系统课时

实现字符设备读写接口

实现字符设备读写接口

这一节把一个最小字符设备真正接到用户态:内核模块分配设备号、注册 cdev 和 file_operations,再创建 /dev/anystack_char。完成后可直接用 printf 写入、用 cat 读回,并能据此理解 VFS 到驱动回调的调用路径。

学习目标

  • 理解设备号、cdev、file_operations 与设备节点之间的关系。
  • 实现 open、read、write、release 并正确处理用户态数据拷贝。
  • 编译、加载模块并用标准文件命令验证字符设备读写。

从文件操作落到驱动回调

用户态并不会直接调用驱动函数。程序先对 /dev/anystack_char 执行 open、read、write,VFS 根据设备节点里的主次设备号找到已注册的 cdev,再通过 file_operations 分派到驱动回调。

字符设备从用户态到驱动回调的数据路径

设备号负责“找到哪个字符设备”,cdev 把这个编号登记到字符设备框架,file_operations 则定义“找到以后能做什么”。device_create 创建 sysfs 设备并触发用户空间设备管理器生成 /dev 节点;在精简系统里若没有 devtmpfs、udev/mdev,也可以手工 mknod。

写一个可工作的字符设备

下面模块为每个设备保存一个 256 字节缓冲区。write 把用户数据复制进内核缓冲区,read 通过 simple_read_from_buffer 按文件偏移读出;互斥锁避免并发读写时看到一半更新的数据。代码兼容新旧 class_create 签名,便于在不同长期支持内核上练习。

c
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/uaccess.h>
#include <linux/version.h>

#define DEVICE_NAME "anystack_char"
#define BUF_SIZE 256

/* 设备对象集中保存注册信息、并发保护和共享数据。 */
struct demo_dev {
    struct cdev cdev;
    struct mutex lock;
    char buf[BUF_SIZE];
    size_t data_len;
};

static dev_t devno;
static struct class *demo_class;
static struct demo_dev demo;

static int demo_open(struct inode *inode, struct file *file)
{
    /* 后续回调通过 private_data 取回当前设备对象。 */
    file->private_data = container_of(inode->i_cdev, struct demo_dev, cdev);
    return 0;
}

static ssize_t demo_read(struct file *file, char __user *ubuf,
                         size_t count, loff_t *ppos)
{
    struct demo_dev *dev = file->private_data;
    ssize_t ret;

    if (mutex_lock_interruptible(&dev->lock))
        return -ERESTARTSYS;

    /* helper 会推进 ppos,并在读到 data_len 后返回 EOF。 */
    ret = simple_read_from_buffer(ubuf, count, ppos,
                                  dev->buf, dev->data_len);
    mutex_unlock(&dev->lock);
    return ret;
}

static ssize_t demo_write(struct file *file, const char __user *ubuf,
                          size_t count, loff_t *ppos)
{
    struct demo_dev *dev = file->private_data;
    size_t n = min(count, (size_t)(BUF_SIZE - 1));

    if (mutex_lock_interruptible(&dev->lock))
        return -ERESTARTSYS;

    /* 本示例把一次 write 视为替换当前共享内容。 */
    if (copy_from_user(dev->buf, ubuf, n)) {
        mutex_unlock(&dev->lock);
        return -EFAULT;
    }

    dev->buf[n] = '\0';
    dev->data_len = n;
    *ppos = n;
    mutex_unlock(&dev->lock);
    return n;
}

static int demo_release(struct inode *inode, struct file *file)
{
    return 0;
}

static const struct file_operations demo_fops = {
    .owner = THIS_MODULE,
    .open = demo_open,
    .read = demo_read,
    .write = demo_write,
    .release = demo_release,
    .llseek = default_llseek,
};

static int __init demo_init(void)
{
    struct device *created;
    int ret;

    mutex_init(&demo.lock);

    ret = alloc_chrdev_region(&devno, 0, 1, DEVICE_NAME);
    if (ret)
        return ret;

    cdev_init(&demo.cdev, &demo_fops);
    demo.cdev.owner = THIS_MODULE;

    /* cdev 生效后再创建 class 和 device,失败时反向回滚。 */
    ret = cdev_add(&demo.cdev, devno, 1);
    if (ret)
        goto err_unregister;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 4, 0)
    demo_class = class_create(DEVICE_NAME);
#else
    demo_class = class_create(THIS_MODULE, DEVICE_NAME);
#endif
    if (IS_ERR(demo_class)) {
        ret = PTR_ERR(demo_class);
        goto err_cdev;
    }

    created = device_create(demo_class, NULL, devno, NULL, DEVICE_NAME);
    if (IS_ERR(created)) {
        ret = PTR_ERR(created);
        goto err_class;
    }

    pr_info("%s: registered major=%d minor=%d\n",
            DEVICE_NAME, MAJOR(devno), MINOR(devno));
    return 0;

err_class:
    class_destroy(demo_class);
err_cdev:
    cdev_del(&demo.cdev);
err_unregister:
    unregister_chrdev_region(devno, 1);
    return ret;
}

static void __exit demo_exit(void)
{
    device_destroy(demo_class, devno);
    class_destroy(demo_class);
    cdev_del(&demo.cdev);
    unregister_chrdev_region(devno, 1);
}

module_init(demo_init);
module_exit(demo_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Minimal readable and writable character device");

预期结果

text
源码本身不直接输出;配合下面的 Kbuild Makefile 编译后生成 anystack_char.ko。

这里不能直接解引用 char __user *。copy_from_user、copy_to_user 以及封装了后者的 simple_read_from_buffer 会处理用户地址访问;失败时返回 -EFAULT。read 还必须尊重 *ppos,否则 cat 可能反复读到同一批字节而无法到达 EOF。

编译并创建设备节点

把源码保存为 anystack_char.c,同目录创建下面的 Kbuild Makefile。$(MAKE) -C ... M=$(PWD) modules 让当前目录作为外部模块参与内核构建。

makefile
obj-m += anystack_char.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

生效行为与验证方法:执行 make 后应出现 anystack_char.ko;如果目标板不能本机编译,应使用与目标内核完全匹配的交叉编译工具链和内核构建目录生成模块,再复制到板端加载。

加载并验证读写:

bash
make >/dev/null
sudo insmod anystack_char.ko
test -e /dev/anystack_char && echo "node-ready"
printf 'hello-driver' | sudo tee /dev/anystack_char >/dev/null
sudo cat /dev/anystack_char
sudo rmmod anystack_char

预期输出

text
node-ready
hello-driver

若没有自动出现设备节点,先查看 dmesg 中打印的主设备号,再按实际值执行 sudo mknod /dev/anystack_char c <MAJOR> 0。<MAJOR> 是动态值,不要写死;生产系统通常交给 devtmpfs、udev 或 mdev 管理。

处理边界和生命周期

write 返回值表示本次实际接收的字节数,不能无条件返回用户请求的 count。本例最多保存 255 字节并保留字符串终止符,因此更长输入会发生短写;真实驱动应根据硬件 FIFO、DMA 缓冲区或环形队列语义决定是否阻塞、短写或返回错误。

初始化失败时必须按“后创建、先释放”回滚:device_create 之后对应 device_destroy,class_create 对应 class_destroy,cdev_add 对应 cdev_del,设备号最终由 unregister_chrdev_region 归还。模块退出路径也保持同样顺序,避免留下悬空设备节点或已占用的设备号。

如果设备具有每次打开独立的上下文,可在 open 分配对象并放进 file->private_data,在 release 释放;如果像本例一样所有进程共享硬件状态,则应把共享状态放在设备对象中,并用锁、等待队列或原子操作定义清晰的并发语义。标准文件接口能表达的行为优先使用 read、write、poll、mmap,不要把普通数据通道塞进私有控制命令。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

实现字符设备读写接口

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通