C++ `vfio` / `uio`：用户态驱动开发与设备直接访问 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

哈喽，各位好！今天咱们聊聊C++里那些“不正经”的驱动开发方式：vfio和uio，让你们感受一下用户态直接操控硬件的快感（和痛苦）。

一、开场白：为啥要这么折腾？

你是不是觉得驱动就该是内核大佬们的事情？咱普通程序员就该老老实实写应用？嗯，理论上是这样。但有时候，你就是想搞点“特别”的，比如：

性能控： 内核那一层层抽象和安全检查，总是让你觉得慢？想绕过它们，直接和硬件对话，榨干每一滴性能？
调试狂： 内核调试？那画面太美我不敢看。用户态调试器，GDB、LLDB随便用，岂不美哉？
作死爱好者： 就是想体验一下“手搓”硬件的乐趣，感受一下把系统搞崩的快感（误）。

如果以上任何一条戳中了你，那么vfio和uio就是为你准备的“毒药”。

二、uio：简单粗暴的入门

uio（Userspace I/O）是“用户态I/O”的简称，听名字就知道，它是让你在用户态搞I/O的。它的原理非常简单：

内核模块： 提供一个简单的内核模块，负责把硬件资源（中断、内存区域）暴露给用户空间。
设备文件： 创建一个设备文件（通常在/dev/uioX），用户空间通过读写这个文件来和硬件交互。

优点： 简单，容易上手。
缺点： 功能有限，性能较差，安全性较低。

代码示例：uio驱动加载与简单读取

首先，你需要一个简单的uio驱动内核模块（例如uio_pci_generic）。大部分Linux发行版都自带了这个模块。如果没有，你需要自己编译安装。

# 加载 uio_pci_generic 模块，并指定 PCI 设备
modprobe uio_pci_generic id=8086:10f9 # 替换成你的PCI设备ID

# 查看是否加载成功，找到对应的 uio 设备
ls /dev/uio*

接下来，C++代码：

#include <iostream>
#include <fstream>
#include <string>
#include <sstream>

int main() {
    std::string uio_dev = "/dev/uio0"; // 假设是 /dev/uio0，根据你的实际情况修改
    std::ifstream uio_data(uio_dev + ".data"); // 读取设备的信息

    if (!uio_data.is_open()) {
        std::cerr << "Error opening " << uio_dev + ".data" << std::endl;
        return 1;
    }

    std::string line;
    while (std::getline(uio_data, line)) {
        std::cout << line << std::endl;
    }

    uio_data.close();

    std::ofstream uio_map0(uio_dev + ".map0"); // 映射内存区域
    if (!uio_map0.is_open()) {
        std::cerr << "Error opening " << uio_dev + ".map0" << std::endl;
        return 1;
    }

    std::string mem_address_str;
    std::ifstream mem_address_file(uio_dev + ".addr");
    if (mem_address_file.is_open()) {
      std::getline(mem_address_file, mem_address_str);
      mem_address_file.close();
    } else {
      std::cerr << "Error opening " << uio_dev + ".addr" << std::endl;
      return 1;
    }

    unsigned long mem_address = std::stoul(mem_address_str, nullptr, 16);

    std::cout << "Memory Address: 0x" << std::hex << mem_address << std::endl;

    // 读取数据（简单示例，读取第一个字节）
    std::ifstream uio_port(uio_dev); // 打开设备文件
    if (!uio_port.is_open()) {
        std::cerr << "Error opening " << uio_dev << std::endl;
        return 1;
    }

    char buffer[1];
    uio_port.read(buffer, 1); // 从设备文件读取一个字节
    uio_port.close();

    std::cout << "Read value: 0x" << std::hex << (int)(unsigned char)buffer[0] << std::endl;

    return 0;
}

解释：

读取设备信息： uioX.data 文件包含设备的基本信息，例如设备名称、中断号等。
内存映射： 你需要读取 uioX.addr 得到内存地址，然后使用 mmap 将设备的内存区域映射到用户空间。
读取数据： 直接从 /dev/uioX 读取数据。注意，这只是一个非常简单的示例，实际使用中你需要根据硬件的寄存器布局进行更复杂的操作。

注意事项：

权限： 你需要确保用户有权限访问 /dev/uioX 设备文件。
安全： uio 的安全性较低，因为它允许用户空间直接访问硬件。请谨慎使用。
中断处理： uio 的中断处理也比较麻烦，你需要自己实现中断处理函数，并使用 select 或 poll 等机制来等待中断。

三、vfio：真正的硬核玩家

vfio（Virtual Function I/O）是“虚拟功能I/O”的简称。它比uio更强大，也更复杂。vfio的主要目的是为了实现虚拟机（VM）的设备直通（PCI passthrough）。但它也可以用于用户态驱动开发。

原理：

内核模块： 提供一个内核模块，负责把物理设备从宿主机隔离出来，并将其分配给指定的vfio组。
设备文件： 为每个vfio组创建一个设备文件（通常在/dev/vfio/vfio），用户空间通过ioctl系统调用来控制和访问设备。
DMA Remapping： vfio 使用 IOMMU (Input/Output Memory Management Unit) 来实现 DMA remapping，保证了虚拟机的安全。

优点：

性能更好： vfio 允许用户空间直接访问设备的内存和寄存器，避免了内核的额外开销。
安全性更高： vfio 使用 IOMMU 来进行 DMA remapping，防止虚拟机访问宿主机的内存。
功能更强大： vfio 支持中断、DMA、reset等各种硬件功能。

缺点：

配置复杂： 你需要启用 IOMMU，并配置 vfio 驱动。
编程难度高： 你需要熟悉 ioctl 系统调用，并了解设备的寄存器布局。
对硬件有要求： 你需要支持 IOMMU 的硬件。

代码示例：vfio设备打开与简单读取

1. 启用 IOMMU

首先，确保你的 CPU 和主板支持 IOMMU，并且在 BIOS 中启用了 IOMMU。然后，在内核启动参数中添加 intel_iommu=on 或 amd_iommu=on。

2. 找到 VFIO 组

# 找到你想要控制的 PCI 设备
lspci -nn

# 找到该设备对应的 VFIO 组
find /sys/kernel/iommu_groups/ -type l -print0 |
  while IFS= read -r -d $'' group; do
    echo "IOMMU Group: ${group}";
    find "${group}"/devices/ -type l -print0 |
      while IFS= read -r -d $'' device; do
        echo "  Device: $(basename ${device})"
      done
  done

3. 加载 vfio-pci 驱动

# 解绑设备与现有驱动
echo "8086:10f9" > /sys/bus/pci/drivers/e1000e/unbind # 替换成你的设备和驱动

# 加载 vfio-pci 驱动
modprobe vfio-pci ids=8086:10f9 # 替换成你的设备ID

4. C++ 代码:

#include <iostream>
#include <fstream>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <cstdint>

#include <linux/vfio.h> // 需要安装 libvfio-dev 包

int main() {
    int vfio_group_fd = open("/dev/vfio/2", O_RDWR); // 替换成你的 VFIO 组 ID
    if (vfio_group_fd < 0) {
        std::cerr << "Error opening VFIO group" << std::endl;
        return 1;
    }

    // 检查 VFIO API 版本
    int vfio_api_version = ioctl(vfio_group_fd, VFIO_GET_API_VERSION);
    if (vfio_api_version != VFIO_API_VERSION) {
        std::cerr << "VFIO API version mismatch" << std::endl;
        close(vfio_group_fd);
        return 1;
    }

    // 检查 VFIO 组是否安全
    if (ioctl(vfio_group_fd, VFIO_CHECK_EXTENSION, VFIO_TYPE1_IOMMU) == 0) {
        std::cout << "VFIO group is safe" << std::endl;
    } else {
        std::cerr << "VFIO group is not safe" << std::endl;
        close(vfio_group_fd);
        return 1;
    }

    // 创建 VFIO 设备
    int vfio_device_fd = ioctl(vfio_group_fd, VFIO_GET_DEVICE_FD, "0000:00:1c.0"); // 替换成你的 PCI 设备 BDF
    if (vfio_device_fd < 0) {
        std::cerr << "Error getting VFIO device FD" << std::endl;
        close(vfio_group_fd);
        return 1;
    }

    // 获取设备的 PCI 配置空间信息
    struct vfio_region_info region_info = { .argsz = sizeof(region_info) };
    region_info.index = VFIO_PCI_CONFIG_REGION_INDEX; // PCI 配置空间
    if (ioctl(vfio_device_fd, VFIO_GET_REGION_INFO, &region_info) < 0) {
        std::cerr << "Error getting region info" << std::endl;
        close(vfio_device_fd);
        close(vfio_group_fd);
        return 1;
    }

    // 映射 PCI 配置空间
    void* config_space = mmap(nullptr, region_info.size, PROT_READ | PROT_WRITE, MAP_SHARED, vfio_device_fd, region_info.offset);
    if (config_space == MAP_FAILED) {
        std::cerr << "Error mapping region" << std::endl;
        close(vfio_device_fd);
        close(vfio_group_fd);
        return 1;
    }

    // 读取 PCI 设备 ID (Vendor ID)
    uint16_t vendor_id = *(uint16_t*)config_space;
    std::cout << "Vendor ID: 0x" << std::hex << vendor_id << std::endl;

    // 取消映射
    munmap(config_space, region_info.size);

    // 关闭文件描述符
    close(vfio_device_fd);
    close(vfio_group_fd);

    return 0;
}

解释：

打开 VFIO 组： 打开 /dev/vfio/vfio 设备文件，并使用 ioctl 获取 VFIO 组的文件描述符。
检查 VFIO API 版本和安全性： 确保你的 VFIO API 版本与内核版本匹配，并检查 VFIO 组是否安全。
创建 VFIO 设备： 使用 ioctl 创建 VFIO 设备，并获取设备的文件描述符。
获取 PCI 配置空间信息： 使用 ioctl 获取 PCI 配置空间的地址和大小。
映射 PCI 配置空间： 使用 mmap 将 PCI 配置空间映射到用户空间。
读取数据： 直接从映射的内存区域读取数据。
取消映射： 使用 munmap 取消内存映射。
关闭文件描述符： 关闭所有打开的文件描述符。

注意事项：

权限： 你需要确保用户有权限访问 /dev/vfio/vfio 设备文件。
IOMMU： vfio 依赖于 IOMMU，你需要确保 IOMMU 正常工作。
寄存器布局： 你需要了解设备的寄存器布局，才能正确地访问和控制设备。
中断处理： vfio 的中断处理也比较复杂，你需要使用 ioctl 来配置中断，并使用 select 或 poll 等机制来等待中断。

四、uio vs vfio：选择困难症？

特性	`uio`	`vfio`
复杂度	简单	复杂
性能	较低	较高
安全性	较低	较高
功能	有限	强大
适用场景	简单原型验证，低速设备	高性能设备，需要 DMA 和中断支持的场景
IOMMU需求	不需要	需要
调试难度	简单	相对复杂

总结：

如果你只是想快速验证一个简单的想法，或者控制一个低速设备，那么 uio 是一个不错的选择。
如果你需要高性能，或者需要使用 DMA 和中断等高级功能，那么 vfio 才是你的菜。

五、用户态驱动开发：一些“坑”

用户态驱动开发虽然很爽，但也充满了“坑”。

安全性： 用户态驱动可以直接访问硬件，一旦出现 bug，可能会导致系统崩溃。
兼容性： 用户态驱动的兼容性不如内核驱动好，可能会受到内核版本和硬件平台的限制。
调试： 用户态驱动的调试虽然比内核驱动简单，但也需要一定的技巧。
同步： 在多线程环境下，你需要自己处理同步问题，避免出现竞争条件。
中断处理： 用户态中断处理通常涉及轮询或者事件驱动模型，相比内核态中断处理更为复杂。

六、总结：胆大心细，拥抱硬件！

vfio 和 uio 都是强大的工具，可以让你在用户态直接操控硬件。但它们也需要你付出更多的努力和耐心。希望通过今天的分享，你能对用户态驱动开发有一个初步的了解，并勇敢地拥抱硬件！

记住，玩硬件有风险，操作需谨慎！祝各位玩得开心，也玩得安全！如果以后还有什么问题，欢迎提问！

发表回复 取消回复

发表回复取消回复