linux内核模块 字符设备驱动模板

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

• 前言
• 一、linux内核模块是什么？
• 二、代码示例
• 总结

前言

提示：这里可以添加本文要记录的大概内容：

内核版本 5.10.92
linux内核模块 字符设备驱动模板
cdev注册字符设备，创建一个/dev/下设备节点和/sys下的设备节点
方便调试

提示：以下是本篇文章正文内容，下面案例可供参考

一、linux内核模块是什么？

Linux 内核模块是独立于内核主体的程序代码块，它们可以在系统运行时被动态加载到内核中或从内核中卸载。这种特性使得内核能够保持精简并仅包含最基本的组件，同时又能够在需要时扩展功能。

加载模块：
insmod xxx.ko 或 modprobe xxx.ko（命令可以自动处理模块依赖关系并加载所需的模块。）

卸载模块：
rmmod xxx.ko

查看模块：
lsmod

二、代码示例

Makefile

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

module_char_test.c

#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/sysfs.h>

#define DEVICE_NAME "mychardev"
#define CLASS_NAME "mychardev_class"

static dev_t dev_num; // 设备号
static struct cdev my_cdev; // cdev 结构体
static struct class *my_class; // 设备类
static struct device * my_device;


// 设备打开操作
static int my_open(struct inode *inode, struct file *file)
{
    // 在这里执行打开设备的操作
    return 0;
}

// 设备关闭操作
static int my_release(struct inode *inode, struct file *file)
{
    // 在这里执行关闭设备的操作
    return 0;
}

// 设备读取操作
static ssize_t my_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
    // 在这里执行读取数据的操作
    return count;
}

// 设备写入操作
static ssize_t my_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
    // 在这里执行写入数据的操作
    char command[256];
    int cmd = 0;
    int ret = 0;
    
    if (count > sizeof(command) - 1) {
        return -EINVAL;
    }
    
    ret = copy_from_user(command, buf, count);
    if (ret) {
        return -EFAULT;
    }

    // 终止字符串
    command[count] = '\0';
    
    sscanf(command, "%d", &cmd);
    printk("cmd = %d\n", cmd);


    return count;
}

// 设备 ioctl 操作
static long my_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    // 在这里执行 ioctl 操作
    return 0;
}


// 设备操作函数表
static const struct file_operations fops = {
    .owner          = THIS_MODULE,
    .open           = my_open,
    .release        = my_release,
    .read           = my_read,
    .write          = my_write,
    .unlocked_ioctl          = my_ioctl,
};



static ssize_t show_my_sysfs_node(struct device *dev, struct device_attribute *attr, char *buf)
{
    /* 这里实现读取 sysfs 文件的内容 */
    return sprintf(buf, "Hello from the kernel!\n");
}

static ssize_t store_my_sysfs_node(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
    /* 这里实现写入 sysfs 文件的行为 */
    pr_info("Received '%.*s'\n", (int)count, buf);
    return count;
}

static DEVICE_ATTR(my_sysfs_node, 0644, show_my_sysfs_node, store_my_sysfs_node);

// 模块加载时的初始化函数
static int __init my_init(void)
{
    int result;

    // 动态分配设备号
    result = alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME);
    if (result < 0) {
        printk(KERN_ERR "Failed to allocate character device region.\n");
        return result;
    }

    // 初始化 cdev 结构体
    cdev_init(&my_cdev, &fops);

    // 注册 cdev
    result = cdev_add(&my_cdev, dev_num, 1);
    if (result) {
        unregister_chrdev_region(dev_num, 1);
        printk(KERN_ERR "Failed to add cdev.\n");
        return result;
    }

    // 创建设备类
    my_class = class_create(THIS_MODULE, CLASS_NAME);
    if (IS_ERR(my_class)) {
        cdev_del(&my_cdev);
        unregister_chrdev_region(dev_num, 1);
        printk(KERN_ERR "Failed to create device class.\n");
        return PTR_ERR(my_class);
    }

    // 创建设备节点
    my_device = device_create(my_class, NULL, dev_num, NULL, DEVICE_NAME);

    printk(KERN_INFO "Character device '%s' created with major number %d.\n", DEVICE_NAME, MAJOR(dev_num));

    // 创建 sysfs 文件节点
    device_create_file(my_device, &dev_attr_my_sysfs_node);

    return 0;
}

// 模块卸载时的清理函数
static void __exit my_exit(void)
{
    // 删除 sysfs 文件节点
    device_remove_file(my_device, &dev_attr_my_sysfs_node);
    // 删除设备节点
    device_destroy(my_class, dev_num);

    // 删除设备类
    class_destroy(my_class);

    // 删除 cdev
    cdev_del(&my_cdev);

    // 释放设备号
    unregister_chrdev_region(dev_num, 1);

    printk(KERN_INFO "Character device '%s' removed.\n", DEVICE_NAME);
}

module_init(my_init);
module_exit(my_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("A simple character device driver.");

总结

linux内核模块 字符设备驱动模板，可以编译运行，代码仅供参考可以调试使用