Linux 驱动开发详解：从入门到实践

本文带你深入理解Linux内核驱动的核心机制，掌握从零编写字符设备驱动的完整流程

一、Linux驱动概述：内核与硬件的桥梁

Linux驱动是操作系统内核的一部分，负责管理硬件设备并向上层应用程序提供统一接口。其核心价值在于：

1. 抽象硬件细节：让应用程序无需关心硬件具体实现

2. 统一设备接口：通过标准接口（如字符设备、块设备）访问硬件

3. 内核级资源管理：直接操作硬件寄存器，管理中断、DMA等

Linux驱动的类型：

驱动类型	特点	典型设备
字符设备	按字节流访问，顺序读写	键盘、鼠标、串口
块设备	按数据块访问，支持随机读写	硬盘、SSD、U盘
网络设备	处理网络数据包	网卡、WiFi适配器
杂项设备	简单设备的标准框架	LED、蜂鸣器、简单IO

二、开发环境搭建

1. 安装必要工具

# Ubuntu/Debian
sudo apt install build-essential linux-headers-$(uname -r)

# CentOS/RHEL
sudo yum groupinstall "Development Tools"
sudo yum install kernel-devel-$(uname -r)

2. 验证内核头文件

ls -d /lib/modules/$(uname -r)/build
# 应显示有效路径而非"不存在"

三、第一个驱动：Hello World模块

创建 hello.c：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Simple Hello World module");

static int __init hello_init(void)
{
    printk(KERN_INFO "Hello, Linux Kernel World!\n");
    return 0;
}

static void __exit hello_exit(void)
{
    printk(KERN_INFO "Goodbye, Kernel Space!\n");
}

module_init(hello_init);
module_exit(hello_exit);

创建 Makefile：

obj-m += hello.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            # 编译模块
sudo insmod hello.ko  # 加载模块
dmesg | tail -2 # 查看内核日志
sudo rmmod hello      # 卸载模块
dmesg | tail -1       # 验证卸载消息

四、字符设备驱动开发实战

1. 核心数据结构

file_operations - 定义设备操作函数集：

struct file_operations {
    loff_t (*llseek) (struct file *, loff_t, int);
    ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
    long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
    int (*open) (struct inode *, struct file *);
    int (*release) (struct inode *, struct file *);
};

2. 设备注册完整流程

创建 chardev.c：

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>

#define DEVICE_NAME "mychardev"
#define BUFFER_SIZE 1024

static dev_t dev_num;
static struct cdev my_cdev;
static char device_buffer[BUFFER_SIZE];

static int device_open(struct inode *inode, struct file *file)
{
    printk(KERN_INFO "Device opened\n");
    return 0;
}

static int device_release(struct inode *inode, struct file *file)
{
    printk(KERN_INFO "Device closed\n");
    return 0;
}

static ssize_t device_read(struct file *filp, char __user *buf, 
                          size_t len, loff_t *off)
{
    size_t bytes_read = 0;
    const char *message = "Hello from kernel space!\n";
    size_t message_len = strlen(message);
    
    if (*off >= message_len)
        return 0;
    
    if (len > message_len - *off)
        len = message_len - *off;
    
    if (copy_to_user(buf, message + *off, len))
        return -EFAULT;
    
    *off += len;
    return len;
}

static ssize_t device_write(struct file *filp, const char __user *buf,
                           size_t len, loff_t *off)
{
    if (len > BUFFER_SIZE)
        len = BUFFER_SIZE;
    
    if (copy_from_user(device_buffer, buf, len))
        return -EFAULT;
    
    printk(KERN_INFO "Received %zu bytes: %s\n", len, device_buffer);
    return len;
}

static struct file_operations fops = {
    .owner = THIS_MODULE,
    .open = device_open,
    .release = device_release,
    .read = device_read,
    .write = device_write,
};

static int __init chardev_init(void)
{
    // 1. 分配设备号
    if (alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME) < 0) {
        printk(KERN_ALERT "Failed to allocate device number\n");
        return -1;
    }
    
    // 2. 初始化cdev结构
    cdev_init(&my_cdev, &fops);
    
    // 3. 添加设备到系统
    if (cdev_add(&my_cdev, dev_num, 1) < 0) {
        unregister_chrdev_region(dev_num, 1);
        printk(KERN_ALERT "Failed to add cdev\n");
        return -1;
    }
    
    printk(KERN_INFO "Registered char device with major %d\n", MAJOR(dev_num));
    return 0;
}

static void __exit chardev_exit(void)
{
    // 4. 清理资源
    cdev_del(&my_cdev);
    unregister_chrdev_region(dev_num, 1);
    printk(KERN_INFO "Unregistered char device\n");
}

module_init(chardev_init);
module_exit(chardev_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Simple Character Device Driver");

更新Makefile：

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

3. 测试字符设备

# 编译加载
make
sudo insmod chardev.ko

# 查看分配的主设备号
dmesg | tail -1
# 示例输出: Registered char device with major 243

# 创建设备文件
sudo mknod /dev/mychardev c 243 0
sudo chmod 666 /dev/mychardev

# 测试设备
echo "Test message" > /dev/mychardev
cat /dev/mychardev

# 查看内核日志
dmesg | tail -3
# 应显示：
#   Received 12 bytes: Test message
#   Device opened
#   Device closed

五、高级主题：驱动开发关键技术

1. IOCTL接口实现

#include <linux/ioctl.h>

#define MYCHAR_MAGIC 'k'
#define MYCHAR_RESET _IO(MYCHAR_MAGIC, 0)
#define MYCHAR_SET_MAXLEN _IOW(MYCHAR_MAGIC, 1, int)

static long device_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    switch(cmd) {
        case MYCHAR_RESET:
            memset(device_buffer, 0, BUFFER_SIZE);
            printk(KERN_INFO "Buffer reset\n");
            break;
            
        case MYCHAR_SET_MAXLEN:
            if (arg > BUFFER_SIZE)
                return -EINVAL;
            // 实现设置逻辑
            break;
            
        default:
            return -ENOTTY;
    }
    return 0;
}

2. 用户空间与内核空间数据交换

安全拷贝函数：

// 用户->内核
copy_from_user(kernel_buf, user_buf, len);

// 内核->用户
copy_to_user(user_buf, kernel_buf, len);

3. 同步与互斥机制

#include <linux/mutex.h>

static DEFINE_MUTEX(device_lock);

static ssize_t device_write(struct file *filp, const char __user *buf,
                           size_t len, loff_t *off)
{
    mutex_lock(&device_lock);
    // 临界区操作
    mutex_unlock(&device_lock);
    return len;
}

六、调试与问题排查

常用调试技巧：

printk日志分级：

printk(KERN_DEBUG "Debug message");    // 调试信息
printk(KERN_INFO "Information");       // 普通信息
printk(KERN_WARNING "Warning");        // 警告
printk(KERN_ERR "Error occurred");     // 错误

动态调试：

# 启用特定文件的调试信息
echo 'file chardev.c +p' > /sys/kernel/debug/dynamic_debug/control

内核Oops分析：

• 安装 crash 工具

• 保存 /var/log/messages 或 dmesg 输出

• 使用 addr2line 定位问题代码

七、最佳实践与安全建议

内存安全：

• 始终验证用户空间传入参数

• 使用 copy_from_user/copy_to_user 代替直接指针访问

• 检查内存分配返回值

错误处理：

• 为所有可能的错误路径提供清理代码

• 使用 goto 实现集中错误处理

资源管理：

int __init my_init(void)
{
    if (alloc_a() != 0)
        goto fail_a;
    
    if (alloc_b() != 0)
        goto fail_b;
    
    return 0;

fail_b:
    free_a();
fail_a:
    return -ENOMEM;
}

八、下一步学习方向

硬件交互：

• I/O端口操作：inb()/outb()

• 内存映射：ioremap()/iounmap()

• 中断处理：request_irq()

设备树(DTS)：

• 现代ARM架构的硬件描述标准

• 替代传统的硬件探测方式

内核子系统：

• 输入子系统（键盘、鼠标）

• 帧缓冲（显示设备）

• USB设备驱动

开源驱动参考：

• Linux内核源码的 drivers/ 目录

• 知名开源硬件项目（如Raspberry Pi驱动）

驱动开发是深入理解Linux内核的绝佳途径。通过动手实践，你将获得操作系统底层运作机制的深刻认知！

附录：实用命令参考

# 查看已加载模块
lsmod

# 显示模块信息
modinfo <module>

# 加载/卸载模块
insmod <module.ko>
rmmod <module>

# 查看内核环形缓冲区
dmesg -wH

# 创建设备文件
mknod /dev/<name> c <major> <minor>