Linux块设备驱动开发

封面图 • 2026-01-12 • 嵌入式

Linux 块设备驱动开发是操作系统内核编程中一个重要的领域，主要用于管理磁盘、SSD、U盘等块设备。块设备与字符设备不同，它以固定大小的数据块（通常为512字节或4KB）进行读写操作。

---

## 一、Linux 块设备的基本概念

### 1. 块设备（Block Device）
- 以数据块（block）为单位进行读写。
- 例如：硬盘（hda, sda）、U盘、SD卡、RAM disk 等。

### 2. 块设备驱动
- 负责与硬件交互，实现读写操作。
- 提供统一的接口给上层应用（如文件系统）使用。

---

## 二、Linux 块设备驱动结构

Linux 内核中的块设备驱动主要涉及以下几个核心结构体和函数：

### 1. `struct block_device`
表示一个块设备实例，由 `blkdev_get()` 或 `open` 系统调用创建。

### 2. `struct gendisk`
表示一个虚拟磁盘（如 `/dev/sda`），包含分区信息、设备号、操作函数等。

### 3. `struct request_queue`
请求队列，用于管理 I/O 请求。

### 4. `struct bio`
I/O 请求的最小单元，表示一个数据块的读写操作。

### 5. `struct request`
表示一个完整的 I/O 请求，可能包含多个 `bio`。

---

## 三、块设备驱动开发流程

### 1. 注册块设备
```c
int register_blkdev(unsigned int major, const char *name);
```

### 2. 创建并初始化 `gendisk`
```c
struct gendisk *alloc_disk(int minors);
void add_disk(struct gendisk *disk);
```

### 3. 定义 I/O 操作函数
```c
struct block_device_operations {
    int (*open)(struct block_device *, fmode_t);
    int (*release)(struct block_device *, fmode_t);
    int (*ioctl)(struct block_device *, fmode_t, unsigned int, unsigned long);
    int (*check_media_change)(struct block_device *);
    int (*revalidate)(struct block_device *);
};
```

### 4. 实现 I/O 处理逻辑
通常通过 `request_queue` 和 `bio` 来处理读写请求。

---

## 四、示例：简单块设备驱动

以下是一个非常基础的块设备驱动示例，模拟一个 RAM Disk（内存磁盘）。

### 1. 驱动代码（简化版）

```c
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/blkdev.h>
#include <linux/genhd.h>
#include <linux/kmalloc.h>

#define DEVICE_NAME "ramdisk"
#define RAMDISK_SIZE (1024 * 1024) // 1MB

static struct gendisk *gd;
static unsigned char *ramdisk;

static int ramdisk_open(struct block_device *bdev, fmode_t mode)
{
    return 0;
}

static int ramdisk_release(struct block_device *bdev, fmode_t mode)
{
    return 0;
}

static int ramdisk_ioctl(struct block_device *bdev, fmode_t mode,
                         unsigned int cmd, unsigned long arg)
{
    return -ENOTTY;
}

static struct block_device_operations ramdisk_fops = {
    .owner = THIS_MODULE,
    .open = ramdisk_open,
    .release = ramdisk_release,
    .ioctl = ramdisk_ioctl,
};

static void ramdisk_request(struct request_queue *q)
{
    struct request *req;
    while ((req = elv_next_request(q)) != NULL) {
        if (req->cmd_type != REQ_TYPE_FS)
            continue;

struct bio *bio;
        int i;
        for (bio = req->bio; bio; bio = bio->bi_next) {
            sector_t sector = bio->bi_sector;
            unsigned int len = bio->bi_size / 512;
            unsigned char *data = bio_data(bio);

if (bio_data_dir(bio) == READ) {
                memcpy(data, ramdisk + sector * 512, len * 512);
            } else {
                memcpy(ramdisk + sector * 512, data, len * 512);
            }
        }

__end_request(req, 1); // 成功完成
    }
}

static int __init ramdisk_init(void)
{
    int major = register_blkdev(0, DEVICE_NAME);
    if (major < 0) {
        printk(KERN_ERR "Failed to register ramdisk\n");
        return major;
    }

ramdisk = kmalloc(RAMDISK_SIZE, GFP_KERNEL);
    if (!ramdisk) {
        unregister_blkdev(major, DEVICE_NAME);
        return -ENOMEM;
    }

gd = alloc_disk(1);
    if (!gd) {
        kfree(ramdisk);
        unregister_blkdev(major, DEVICE_NAME);
        return -ENOMEM;
    }

gd->major = major;
    gd->first_minor = 0;
    gd->minors = 1;
    gd->fops = &ramdisk_fops;
    gd->private_data = ramdisk;
    strcpy(gd->disk_name, DEVICE_NAME);

// 初始化请求队列
    gd->queue = blk_alloc_queue(GFP_KERNEL);
    if (!gd->queue) {
        put_disk(gd);
        kfree(ramdisk);
        unregister_blkdev(major, DEVICE_NAME);
        return -ENOMEM;
    }

blk_queue_make_request(gd->queue, ramdisk_request);
    blk_queue_max_hw_sectors(gd->queue, RAMDISK_SIZE / 512);
    blk_queue_logical_block_size(gd->queue, 512);

add_disk(gd);
    printk(KERN_INFO "RAM Disk initialized.\n");
    return 0;
}

static void __exit ramdisk_exit(void)
{
    del_gendisk(gd);
    put_disk(gd);
    blk_cleanup_queue(gd->queue);
    kfree(ramdisk);
    unregister_blkdev(gd->major, DEVICE_NAME);
    printk(KERN_INFO "RAM Disk removed.\n");
}

module_init(ramdisk_init);
module_exit(ramdisk_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Simple RAM Disk Block Device Driver");
```

---

## 五、编译与测试

### 1. 编译模块
将上述代码保存为 `ramdisk.c`，然后编写 Makefile：

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

运行：
```bash
make
sudo insmod ramdisk.ko
```

### 2. 查看设备
```bash
fdisk -l | grep ramdisk
```

### 3. 格式化与挂载
```bash
mkfs.ext4 /dev/ramdisk
mount /dev/ramdisk /mnt
```

---

## 六、常见问题与调试技巧

| 问题 | 解决方法 |
|------|----------|
| 设备无法识别 | 检查 `register_blkdev` 是否成功，是否注册了 `gendisk` |
| 读写失败 | 检查 `request_queue` 和 `bio` 的处理逻辑 |
| 内存泄漏 | 使用 `kfree` 释放分配的内存 |
| 模块加载失败 | 检查 `Makefile` 和内核版本兼容性 |

---

## 七、进阶内容

- **DMA 支持**：使用 DMA 传输数据，提高性能。
- **异步 I/O**：使用 `submit_bio` 异步处理 I/O 请求。
- **多线程支持**：在驱动中使用工作队列或线程池处理请求。
- **设备树支持**：适用于嵌入式 Linux 平台。
- **块设备文件系统支持**：如 ext4、XFS 等。

---

## 八、参考资料

- 《Linux设备驱动程序》（Linux Device Drivers, 3rd Edition）
- Linux 内核源码：`include/linux/blkdev.h`, `drivers/block/`
- [Linux Kernel Documentation](https://www.kernel.org/doc/html/latest/)

---

如果你有具体的开发需求（比如驱动特定硬件、实现某个功能等），欢迎继续提问！我可以帮你进一步分析和设计。