（四）内核那些事儿：设备管理与驱动开发

1. 操作系统与硬件的桥梁

设备管理是操作系统连接软件与硬件的核心机制。理解这个过程的关键在于掌握分层架构：

用户应用程序
    ↓ (系统调用)
虚拟文件系统 (VFS)
    ↓ (设备文件)
设备驱动程序
    ↓ (硬件抽象层)
硬件控制器
    ↓ (电信号)
物理硬件设备

1.1 硬件识别与枚举过程

当硬件设备连接到系统时，会发生以下步骤：

物理检测：总线控制器（如 PCI、USB）检测到新设备插入
设备识别：读取设备的标识信息（Vendor ID、Device ID、Class Code）
驱动匹配：内核根据设备 ID 查找对应的驱动程序
资源分配：为设备分配 I/O 端口、中断号、内存地址等资源
设备注册：通过设备模型和 udev 在 /dev/ 下创建设备文件，供用户空间访问

1.2 设备接入的完整流程详解

阶段 1：硬件层面的设备发现

物理插入 → 总线控制器检测 → 电气信号确认 → 设备枚举开始

// USB设备插入时的物理检测
static irqreturn_t usb_hub_irq(int irq, void *dev_id) {
    struct usb_hub *hub = dev_id;

    // 检测到端口状态变化
    if (hub->status & USB_PORT_STAT_CONNECTION) {
        // 设备插入，开始枚举过程
        schedule_work(&hub->events);
    }
    return IRQ_HANDLED;
}

阶段 2：设备识别与信息读取

// 读取设备描述符获取身份信息
struct usb_device_descriptor {
    __u16 idVendor;     // 厂商ID (如: 0x046d = Logitech)
    __u16 idProduct;    // 产品ID (如: 0xc52b = 鼠标型号)
    __u8  bDeviceClass; // 设备类别 (如: 0x03 = HID设备)
    __u8  bDeviceSubClass;
    __u8  bDeviceProtocol; // 协议 (如: 0x02 = 鼠标协议)
};

// 内核读取这些信息
static int usb_enumerate_device(struct usb_device *udev) {
    struct usb_device_descriptor *desc;

    // 发送GET_DESCRIPTOR请求
    usb_get_descriptor(udev, USB_DT_DEVICE, 0, desc, sizeof(*desc));

    printk("发现设备: VID=0x%04x, PID=0x%04x, Class=0x%02x\n",
           desc->idVendor, desc->idProduct, desc->bDeviceClass);

    return 0;
}

阶段 3：驱动程序匹配与绑定

// 驱动程序注册时声明支持的设备
static struct usb_device_id mouse_id_table[] = {
    // 支持所有HID鼠标设备
    { USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID,
                         USB_INTERFACE_SUBCLASS_BOOT,
                         USB_INTERFACE_PROTOCOL_MOUSE) },
    // 支持特定厂商的鼠标
    { USB_DEVICE(0x046d, 0xc52b) }, // Logitech特定型号
    { }
};

static struct usb_driver mouse_driver = {
    .name = "usbhid",
    .probe = mouse_probe,        // 设备匹配时调用
    .disconnect = mouse_disconnect,
    .id_table = mouse_id_table,  // 支持的设备列表
};

// 内核自动匹配过程
static int usb_match_device(struct usb_device *dev, struct usb_driver *drv) {
    // 遍历驱动的id_table，查找匹配项
    for (id = drv->id_table; id->match_flags; id++) {
        if (usb_match_id(dev, id)) {
            return 1; // 找到匹配的驱动
        }
    }
    return 0;
}

1.3 驱动程序的核心职责

驱动程序需要实现以下核心功能：

// 驱动程序的基本结构
struct device_driver {
    int (*probe)(struct device *);      // 设备发现时调用
    int (*remove)(struct device *);     // 设备移除时调用
    int (*suspend)(struct device *);    // 电源管理
    int (*resume)(struct device *);     // 电源管理
};

// 文件操作接口 - 设备驱动与用户空间交互的核心接口
struct file_operations {
    int (*open)(struct inode *, struct file *);
    ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
    ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
    long (*ioctl)(struct file *, unsigned int, unsigned long);
    int (*release)(struct inode *, struct file *);
};

2. Linux 设备模型与 udev 机制

2.1 Linux 设备模型 (Device Model)

设备模型是 Linux 内核中的一个统一框架，用于组织和管理所有硬件设备：

// 设备模型的核心结构
struct device {
    struct device *parent;      // 父设备（总线关系）
    struct device_private *p;   // 私有数据
    struct kobject kobj;        // 内核对象（sysfs接口）
    const char *init_name;      // 设备名称
    struct device_type *type;   // 设备类型
    struct bus_type *bus;       // 所属总线
    struct device_driver *driver; // 绑定的驱动
    dev_t devt;                 // 设备号 (major:minor)
};

设备模型层次结构：

/sys/devices/
├── pci0000:00/           # PCI总线
│   ├── 0000:00:1d.0/     # USB控制器
│   │   ├── usb2/         # USB总线
│   │   │   └── 2-1/      # USB端口1
│   │   │       └── 2-1:1.0/  # USB接口
│   │   │           └── input/input2/  # 输入设备
│   │   │               └── event2     # 事件设备

// 当驱动调用device_add()时发生什么
int device_add(struct device *dev) {
    // 1. 分配设备号
    if (dev->devt) {
        error = device_create_file(dev, &dev_attr_dev);
    }

    // 2. 创建sysfs目录和属性文件
    error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
    // 这会在 /sys/devices/ 下创建目录

    // 3. 通知设备子系统
    if (dev->class) {
        class_device_add(dev);
    }

    // 4. 发送uevent通知用户空间
    kobject_uevent(&dev->kobj, KOBJ_ADD);

    return 0;
}

2.2 udev - 用户空间设备管理器

udev 是运行在用户空间的守护进程，负责：

监听内核设备事件
根据规则创建/删除设备文件
设置设备文件权限和所有者
创建设备符号链接

// 内核发送uevent的过程
static int kobject_uevent_env(struct kobject *kobj,
                              enum kobject_action action,
                              char *envp_ext[]) {
    // 1. 构造环境变量
    char *envp[] = {
        "ACTION=add",                    // 动作类型
        "DEVPATH=/devices/pci0000:00/...", // 设备路径
        "SUBSYSTEM=input",               // 子系统
        "DEVNAME=input/event2",          // 设备名称
        "MAJOR=13",                      // 主设备号
        "MINOR=66",                      // 次设备号
        NULL
    };

    // 2. 通过netlink socket发送给udev
    return netlink_broadcast_filtered(uevent_sock, skb, 0, 1, GFP_KERNEL,
                                    kobj_bcast_filter, kobj);
}

udev 规则文件示例：

# /etc/udev/rules.d/50-input.rules
# 为所有输入事件设备创建设备文件
KERNEL=="event*", SUBSYSTEM=="input", MODE="0644", GROUP="input"

# 为鼠标设备创建特殊符号链接
KERNEL=="event*", SUBSYSTEM=="input", ATTRS{name}=="*Mouse*", \
    SYMLINK+="input/mouse%n"

# 为触摸板设备设置特殊权限
KERNEL=="event*", SUBSYSTEM=="input", ATTRS{name}=="*TouchPad*", \
    MODE="0664", GROUP="input"

3. 输入设备实例：鼠标驱动开发

3.1 鼠标硬件工作原理

光学传感器 → 微控制器 → USB/PS2接口 → 主机控制器 → CPU
     ↑              ↓
  LED照明      按键状态检测

3.2 驱动程序实现要点

步骤 1：设备注册与初始化

// 鼠标驱动初始化
static int mouse_probe(struct usb_interface *intf,
                       const struct usb_device_id *id) {
    struct usb_device *dev = interface_to_usbdev(intf);
    struct mouse_device *mouse;

    // 1. 分配设备结构体
    mouse = kzalloc(sizeof(struct mouse_device), GFP_KERNEL);

    // 2. 配置USB端点
    mouse->usbdev = dev;
    mouse->irq_in = usb_rcvintpipe(dev, endpoint->bEndpointAddress);

    // 3. 分配URB（USB请求块）
    mouse->urb = usb_alloc_urb(0, GFP_KERNEL);

    // 4. 分配DMA缓冲区
    mouse->data = usb_alloc_coherent(dev, 8, GFP_KERNEL, &mouse->data_dma);

    // 5. 注册输入设备
    mouse->input_dev = input_allocate_device();
    input_set_capability(mouse->input_dev, EV_KEY, BTN_LEFT);
    input_set_capability(mouse->input_dev, EV_REL, REL_X);
    input_set_capability(mouse->input_dev, EV_REL, REL_Y);

    return input_register_device(mouse->input_dev);
}

步骤 2：中断处理与数据解析

// USB中断回调函数 - 由驱动程序执行，运行在内核空间
static void mouse_irq(struct urb *urb) {
    // 执行环境：
    // - 运行在：内核空间
    // - 执行者：内核中断处理机制
    // - 触发者：USB硬件控制器
    // - 上下文：中断上下文（不能睡眠）

    struct mouse_device *mouse = urb->context;
    unsigned char *data = mouse->data;
    struct input_dev *dev = mouse->input_dev;

    // 解析鼠标数据包格式
    // data[0]: 按键状态位 [中键][右键][左键][保留位...]
    // data[1]: X轴增量 (-127 到 +127)
    // data[2]: Y轴增量 (-127 到 +127)
    // data[3]: 滚轮增量

    int left_pressed = data[0] & 0x01;
    int right_pressed = data[0] & 0x02;
    int x_movement = (signed char)data[1];
    int y_movement = (signed char)data[2];

    // 转换为标准输入事件
    if (left_pressed != mouse->last_left_state) {
        input_report_key(dev, BTN_LEFT, left_pressed);
        mouse->last_left_state = left_pressed;
    }

    if (x_movement != 0) {
        input_report_rel(dev, REL_X, x_movement);
    }

    if (y_movement != 0) {
        input_report_rel(dev, REL_Y, y_movement);
    }

    // 提交事件批次到输入子系统
    input_sync(dev);

    // 重新提交URB继续接收数据
    usb_submit_urb(urb, GFP_ATOMIC);
}

3.3 执行模型详解

重要概念：

设备文件：只是一个接口/通道，不包含可执行代码
驱动程序：真正执行数据处理的代码，在系统启动/模块加载时常驻内存

┌─────────────────┐     ┌──────────────────┐     ┌─────────────────┐
│   用户进程      │     │    内核驱动      │     │     硬件        │
│                 │     │                  │     │                 │
│ read() 调用     │────▶│ 从事件队列读取   │     │ 鼠标移动        │
│ (阻塞等待)      │     │                  │     │       ↓         │
│                 │     │                  │     │ USB数据包发送   │
│ 返回事件数据    │◀────│ copy_to_user()   │     │       ↓         │
│                 │     │                  │     │ 触发中断        │
└─────────────────┘     │                  │     │       ↓         │
                        │ mouse_irq()      │◀────│ 硬件中断        │
                        │ ↓                │     │                 │
                        │ 解析数据包       │     └─────────────────┘
                        │ ↓                │
                        │ input_report_*() │
                        │ ↓                │
                        │ 放入事件队列     │
                        └──────────────────┘

执行者：           用户态进程         内核驱动程序           硬件控制器
何时执行：         用户调用read()     硬件中断触发           用户操作硬件

完整执行时序：

时刻1: 鼠标硬件动作
[硬件] 用户移动鼠标 → 光学传感器检测位移

时刻2: 硬件中断产生
[硬件] USB鼠标控制器 → 通过USB总线发送数据包

时刻3: USB控制器中断
[硬件] USB Host Controller → 产生硬件中断 IRQ_USB

时刻4: 内核中断处理
[内核] CPU响应中断 → 保存当前进程上下文 → 跳转到中断向量

时刻5: USB栈处理
[内核] USB中断处理程序 → 识别是哪个URB完成 → 调用回调函数

时刻6: 驱动程序执行
[驱动] mouse_irq() 函数被调用 → 解析数据 → 生成输入事件

时刻7: 输入子系统处理
[内核] input_report_*() → 将事件放入事件队列

时刻8: 用户程序读取
[用户] 用户程序调用 read() → 从设备文件读取事件

3.4 用户空间交互

// 用户程序读取设备文件
int fd = open("/dev/input/event2", O_RDONLY);

struct input_event event;
while (read(fd, &event, sizeof(event)) == sizeof(event)) {
    switch (event.type) {
    case EV_REL:
        if (event.code == REL_X) {
            cursor_x += event.value;  // 更新光标X坐标
        } else if (event.code == REL_Y) {
            cursor_y += event.value;  // 更新光标Y坐标
        }
        break;
    case EV_KEY:
        if (event.code == BTN_LEFT && event.value == 1) {
            handle_left_click();     // 处理左键点击
        }
        break;
    }
}

# 或者通过命令行工具
cat /dev/input/event2  # 读取原始输入事件
evtest /dev/input/event2  # 测试输入设备

# 或者通过X11/Wayland等图形系统处理
# evdev → libinput → X11/Wayland → 应用程序

3.5 关键技术点

异步 I/O：鼠标使用中断传输，无需 CPU 轮询
事件驱动：通过 input 子系统统一管理所有输入事件
缓冲管理：内核维护事件队列，防止数据丢失
电源管理：支持设备休眠和唤醒

4. 文件操作接口详解

在 Linux 中，“一切皆文件” 的设计理念使得设备也被抽象为文件。当用户程序操作设备文件时，内核会调用驱动程序中对应的函数：

用户程序调用    →    系统调用    →    VFS层    →    驱动程序函数
open()         →    sys_open()  →    vfs_open() →    fops->open()
read()         →    sys_read()  →    vfs_read() →    fops->read()

4.1 各个函数指针详解

open() - 设备打开

// 当用户程序调用 open("/dev/mydevice", O_RDWR) 时触发
static int my_device_open(struct inode *inode, struct file *file) {
    struct my_device *dev;

    // 1. 获取设备结构体（通过次设备号）
    int minor = MINOR(inode->i_rdev);
    dev = &my_devices[minor];

    // 2. 检查设备状态
    if (dev->is_busy) {
        return -EBUSY;  // 设备忙
    }

    // 3. 初始化设备
    my_device_hw_init(dev);

    // 4. 设置文件私有数据（重要！）
    file->private_data = dev;

    // 5. 更新使用计数
    dev->usage_count++;

    return 0;  // 成功
}

read() - 从设备读取数据

static ssize_t my_device_read(struct file *file, char __user *buffer,
                              size_t count, loff_t *offset) {
    struct my_device *dev = file->private_data;
    char kernel_buffer[256];
    size_t bytes_to_copy;

    // 1. 从硬件读取数据到内核缓冲区
    bytes_to_copy = my_device_hw_read(dev, kernel_buffer,
                                      min(count, sizeof(kernel_buffer)));

    // 2. 将数据从内核空间复制到用户空间
    if (copy_to_user(buffer, kernel_buffer, bytes_to_copy)) {
        return -EFAULT;  // 内存访问错误
    }

    // 3. 更新文件偏移
    *offset += bytes_to_copy;

    return bytes_to_copy;  // 返回实际读取的字节数
}

write() - 向设备写入数据

static ssize_t my_device_write(struct file *file, const char __user *buffer,
                               size_t count, loff_t *offset) {
    struct my_device *dev = file->private_data;
    char kernel_buffer[256];
    size_t bytes_to_write;

    bytes_to_write = min(count, sizeof(kernel_buffer));

    // 1. 从用户空间复制数据到内核空间
    if (copy_from_user(kernel_buffer, buffer, bytes_to_write)) {
        return -EFAULT;
    }

    // 2. 将数据写入硬件
    if (my_device_hw_write(dev, kernel_buffer, bytes_to_write) < 0) {
        return -EIO;  // I/O错误
    }

    *offset += bytes_to_write;
    return bytes_to_write;
}

ioctl() - 设备控制

// 定义ioctl命令
#define MY_DEVICE_IOC_MAGIC 'M'
#define MY_DEVICE_SET_SPEED    _IOW(MY_DEVICE_IOC_MAGIC, 1, int)
#define MY_DEVICE_GET_STATUS   _IOR(MY_DEVICE_IOC_MAGIC, 2, int)

static long my_device_ioctl(struct file *file, unsigned int cmd,
                            unsigned long arg) {
    struct my_device *dev = file->private_data;
    int __user *user_ptr = (int __user *)arg;
    int value;

    switch (cmd) {
    case MY_DEVICE_SET_SPEED:
        // 从用户空间获取参数
        if (copy_from_user(&value, user_ptr, sizeof(int)))
            return -EFAULT;

        // 设置设备速度
        my_device_set_speed(dev, value);
        break;

    case MY_DEVICE_GET_STATUS:
        // 获取设备状态
        value = my_device_get_status(dev);

        // 返回给用户空间
        if (copy_to_user(user_ptr, &value, sizeof(int)))
            return -EFAULT;
        break;

    default:
        return -ENOTTY;  // 不支持的命令
    }

    return 0;
}

release() - 关闭设备

static int my_device_release(struct inode *inode, struct file *file) {
    struct my_device *dev = file->private_data;

    // 1. 清理资源
    my_device_hw_cleanup(dev);

    // 2. 减少使用计数
    dev->usage_count--;

    // 3. 如果没有进程使用，关闭硬件
    if (dev->usage_count == 0) {
        my_device_hw_shutdown(dev);
    }

    return 0;
}

5. 输出设备实例：显示器驱动开发

5.1 显示系统架构

应用程序 → OpenGL/Vulkan → GPU驱动 → 硬件GPU → 显示控制器 → 显示器
    ↓                          ↓              ↓
合成器(Compositor)         帧缓冲区        HDMI/DP信号

5.2 DRM(Direct Rendering Manager)驱动框架

步骤 1：硬件抽象与初始化

// DRM驱动的核心结构
struct drm_driver my_gpu_driver = {
    .driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC,
    .load = my_gpu_load,
    .unload = my_gpu_unload,
    .fops = &my_gpu_fops,
    .name = "my-gpu",
};

static int my_gpu_load(struct drm_device *dev, unsigned long flags) {
    struct my_gpu_device *gpu;

    // 1. 初始化硬件
    gpu = kzalloc(sizeof(*gpu), GFP_KERNEL);

    // 2. 映射GPU寄存器
    gpu->mmio = ioremap(pci_resource_start(dev->pdev, 0),
                        pci_resource_len(dev->pdev, 0));

    // 3. 分配显存
    gpu->vram_size = my_gpu_get_vram_size(gpu);
    gpu->vram_base = pci_resource_start(dev->pdev, 2);

    // 4. 注册中断处理
    request_irq(dev->pdev->irq, my_gpu_irq_handler,
                IRQF_SHARED, "my-gpu", gpu);

    return 0;
}

步骤 2：模式设置与显示管道

// 显示管道配置
static int my_gpu_crtc_mode_set(struct drm_crtc *crtc,
                                struct drm_display_mode *mode,
                                struct drm_display_mode *adjusted_mode,
                                int x, int y,
                                struct drm_framebuffer *fb) {
    struct my_gpu_device *gpu = crtc_to_gpu(crtc);

    // 1. 配置像素时钟
    my_gpu_set_pixel_clock(gpu, mode->clock);

    // 2. 设置显示时序
    my_gpu_write_reg(gpu, HTOTAL_REG, mode->htotal);
    my_gpu_write_reg(gpu, VTOTAL_REG, mode->vtotal);
    my_gpu_write_reg(gpu, HSYNC_REG, mode->hsync_start);
    my_gpu_write_reg(gpu, VSYNC_REG, mode->vsync_start);

    // 3. 配置帧缓冲地址
    my_gpu_write_reg(gpu, FB_BASE_REG, fb->offset);
    my_gpu_write_reg(gpu, FB_STRIDE_REG, fb->pitches[0]);

    // 4. 启用显示输出
    my_gpu_write_reg(gpu, DISPLAY_CTRL_REG, DISPLAY_ENABLE);

    return 0;
}

步骤 3：内存管理与渲染

// GEM (Graphics Execution Manager) 对象管理
static int my_gpu_gem_create(struct drm_file *file,
                            struct drm_device *dev,
                            uint64_t size,
                            uint32_t *handle_p) {
    struct drm_gem_object *obj;

    // 1. 分配GPU内存对象
    obj = drm_gem_object_alloc(dev, size);

    // 2. 分配实际的显存
    obj->vram_addr = my_gpu_alloc_vram(size);

    // 3. 创建用户句柄
    int ret = drm_gem_handle_create(file, obj, handle_p);

    return ret;
}

// 页错误处理（GPU内存映射）
static vm_fault_t my_gpu_gem_fault(struct vm_fault *vmf) {
    struct drm_gem_object *obj = vmf->vma->vm_private_data;

    // 将GPU显存映射到用户空间
    unsigned long pfn = (obj->vram_addr + offset) >> PAGE_SHIFT;
    return vmf_insert_pfn(vmf->vma, vmf->address, pfn);
}

步骤 4：中断处理与同步

// GPU中断处理
static irqreturn_t my_gpu_irq_handler(int irq, void *arg) {
    struct my_gpu_device *gpu = arg;
    uint32_t status = my_gpu_read_reg(gpu, IRQ_STATUS_REG);

    if (status & VBLANK_IRQ) {
        // 垂直消隐中断：通知用户空间可以提交新帧
        drm_crtc_handle_vblank(&gpu->crtc);

        // 更新帧缓冲（避免撕裂）
        if (gpu->pending_flip) {
            my_gpu_update_scanout(gpu, gpu->pending_flip);
            gpu->pending_flip = NULL;
        }
    }

    if (status & RENDER_COMPLETE_IRQ) {
        // 渲染完成中断：通知等待的进程
        wake_up(&gpu->render_wait_queue);
    }

    return IRQ_HANDLED;
}

5.3 用户空间接口

// 用户程序使用示例
int fd = open("/dev/dri/card0", O_RDWR);

// 1. 获取显示器信息
drmModeRes *resources = drmModeGetResources(fd);

// 2. 创建帧缓冲
struct drm_mode_create_fb create_fb = {
    .width = 1920,
    .height = 1080,
    .pixel_format = DRM_FORMAT_XRGB8888,
};
ioctl(fd, DRM_IOCTL_MODE_ADDFB, &create_fb);

// 3. 设置显示模式
drmModeSetCrtc(fd, crtc_id, fb_id, 0, 0,
               &connector_id, 1, &mode);

// 4. 页面翻转（垂直同步）
drmModePageFlip(fd, crtc_id, new_fb_id,
                DRM_MODE_PAGE_FLIP_EVENT, userdata);

6. 完整设备文件创建时间线

让我们追踪一个鼠标插入时的完整过程：

# 时间线：鼠标插入 → 设备文件出现

时刻1: 硬件检测
[内核] USB控制器检测到新设备插入

时刻2: 设备枚举
[内核] 读取设备描述符: VID=046d, PID=c52b (Logitech鼠标)

时刻3: 驱动匹配
[内核] usbhid驱动匹配成功，调用probe函数

时刻4: 资源分配
[内核] 分配设备号 13:66 (INPUT_MAJOR:66)

时刻5: 设备注册
[内核] input_register_device() → device_add()

时刻6: sysfs创建
[内核] 在/sys/devices/.../ 创建设备目录
[内核] 在/sys/class/input/ 创建event2符号链接

时刻7: uevent发送
[内核] 发送netlink消息:
        ACTION=add
        SUBSYSTEM=input
        DEVNAME=input/event2
        MAJOR=13
        MINOR=66

时刻8: udev处理
[udev] 接收uevent消息
[udev] 匹配规则文件
[udev] 执行: mknod /dev/input/event2 c 13 66
[udev] 设置权限: chmod 644 /dev/input/event2
[udev] 创建符号链接: ln -s event2 /dev/input/mouse0

时刻9: 用户可见
[用户] ls /dev/input/ 可以看到新的设备文件

7. 驱动开发核心要点总结

7.1 通用驱动开发步骤

硬件理解：阅读设备数据手册，理解寄存器布局和时序要求
接口设计：确定设备类型（字符/块/网络设备）和用户接口
资源管理：正确分配和释放 I/O 端口、内存、中断等资源
中断处理：实现高效的中断服务例程，避免长时间占用 CPU
错误处理：处理硬件故障、超时等异常情况
电源管理：支持设备的休眠和唤醒功能
并发控制：使用适当的锁机制保证多线程安全

7.2 完整的驱动注册示例

// 定义file_operations结构体
static struct file_operations my_device_fops = {
    .owner   = THIS_MODULE,
    .open    = my_device_open,
    .read    = my_device_read,
    .write   = my_device_write,
    .unlocked_ioctl = my_device_ioctl,
    .release = my_device_release,
};

// 设备初始化
static int __init my_device_init(void) {
    int ret;

    // 1. 分配设备号
    ret = alloc_chrdev_region(&dev_number, 0, 1, "my_device");
    if (ret < 0) return ret;

    // 2. 创建字符设备
    cdev_init(&my_cdev, &my_device_fops);
    my_cdev.owner = THIS_MODULE;

    // 3. 添加设备到系统
    ret = cdev_add(&my_cdev, dev_number, 1);
    if (ret < 0) {
        unregister_chrdev_region(dev_number, 1);
        return ret;
    }

    // 4. 创建设备文件 /dev/my_device
    device_create(my_class, NULL, dev_number, NULL, "my_device");

    return 0;
}

7.3 调试技巧

# 1. 查看设备信息
lspci -v                    # PCI设备
lsusb -v                    # USB设备
cat /proc/interrupts        # 中断统计
cat /proc/iomem             # 内存映射

# 2. 驱动调试
dmesg | grep my-driver      # 内核日志
debugfs                     # 调试文件系统
ftrace                      # 函数跟踪

# 3. 用户空间测试
evtest /dev/input/event2    # 测试输入设备
xrandr                      # 测试显示设备

# 4. 查看设备模型结构
ls -la /sys/devices/
ls -la /sys/class/input/

# 5. 查看设备属性
udevadm info -a -p /sys/class/input/event2

# 6. 监控udev事件
udevadm monitor

# 7. 测试udev规则
udevadm test /sys/class/input/event2

7.4 性能优化

减少内存拷贝：使用 DMA 直接传输，避免 CPU 参与数据搬移
中断合并：批量处理中断事件，减少上下文切换开销
异步处理：使用工作队列处理耗时操作，避免阻塞中断上下文
缓存友好：合理设计数据结构，提高缓存命中率

7.5 核心理解要点

设备文件不是驱动直接创建的，而是通过设备模型 →udev→ 设备文件的流程
设备文件是数据通道：硬件事件 → 驱动解析 → 输入子系统 → 设备文件 → 用户程序
驱动的核心作用：
- 硬件抽象：将原始电信号转换为标准化事件
- 资源管理：分配和管理硬件资源
- 事件转换：将硬件特定格式转换为通用格式
异步性：硬件事件立即触发中断，驱动立即处理并放入事件队列
file_operations 是驱动的”接口合同”：定义了驱动必须实现的操作
用户空间-内核空间数据传输：必须使用 copy_to_user()/copy_from_user()
私有数据传递：通过 file->private_data 在函数调用间传递设备信息
设备模型提供统一框架，udev 负责根据内核事件和用户定义的规则来创建实际的设备文件
驱动程序在系统启动/模块加载时就常驻内存，等待硬件事件触发执行

通过理解这些核心概念和实现细节，我们可以更好地掌握操作系统如何与硬件协同工作，以及如何编写高质量的设备驱动程序。设备管理的精妙之处在于：它将复杂的硬件操作抽象成了简单的文件操作，让用户程序可以用统一的方式访问各种不同的硬件设备，同时通过分层设计实现了内核空间硬件管理与用户空间策略决策的完美分离。