基于PCIe doorbell同步的系统软件实现-技术-FPGA.AC

欢迎大家关注我的公众号：颇锐克科技共享

PCIe Doorbell工作原理参见:

一、基于Doorbell同步机的软件设计

流程图核心逻辑说明

用户态-内核态交互：通过设备节点和 IOCTL 命令实现跨态通信，触发 DOORBELL 并查询结果。
中断同步链路：从寄存器写入→硬件中断触发→CPU 中断分发→内核中断处理→用户态唤醒，形成完整同步闭环。
并发安全：内核态通过自旋锁保护临界区，避免多线程/进程访问冲突。

二、PCIe DOORBELL 同步实现代码（Linux 内核态）

以下是基于 PCIe 设备中断机制的 DOORBELL 同步核心实现，包含设备初始化、DOORBELL 触发、中断处理及同步逻辑，适配 x86 架构 PCIe 3.0+ 设备：

#include <linux/pci.h>

#include <linux/interrupt.h>

#include <linux/spinlock.h>

#include <linux/delay.h>

// PCIe DOORBELL 寄存器地址定义（示例：BAR0 偏移 0x1000）

#define PCIE\_DOORBELL\_TRIGGER 0x1000  // 写此地址触发 DOORBELL

#define PCIE\_DOORBELL\_CLEAR   0x1004  // 写此地址清除中断

#define DOORBELL\_MAGIC\_VALUE  0x5A5A  // 触发魔术字（需与硬件协商）

// 设备私有数据结构

struct pcie\_doorbell\_dev {

    struct pci\_dev \*pdev;

    void \_\_iomem \*bar0\_base;  // BAR0 映射地址

    spinlock\_t lock;          // 同步自旋锁

    bool is\_triggered;        // DOORBELL 触发状态

    wait\_queue\_head\_t wq;     // 等待队列（用于用户态同步）

};

// PCIe 中断处理函数（DOORBELL 响应回调）

static irqreturn\_t pcie\_doorbell\_irq\_handler(int irq, void \*dev\_id) {

    struct pcie\_doorbell\_dev \*db\_dev = dev\_id;

    u32 status;

    // 1. 读取中断状态（确保是 DOORBELL 触发）

    status = ioread32(db\_dev->bar0\_base + 0x1008);  // 中断状态寄存器

    if (!(status & (1 << 4))) {  // 假设 bit4 是 DOORBELL 中断标志

        return IRQ\_NONE;

    }

    // 2. 临界区操作：更新状态 + 唤醒等待队列

    spin\_lock(&db\_dev->lock);

    db\_dev->is\_triggered = true;

    wake\_up\_interruptible(&db\_dev->wq);  // 唤醒用户态等待线程

    spin\_unlock(&db\_dev->lock);

    // 3. 清除中断（硬件要求：必须清除否则会重复触发）

    iowrite32(1 << 4, db\_dev->bar0\_base + PCIE\_DOORBELL\_CLEAR);

    return IRQ\_HANDLED;

}

// 触发 PCIe DOORBELL（内核态接口）

int pcie\_doorbell\_trigger(struct pcie\_doorbell\_dev \*db\_dev) {

    if (!db\_dev || !db\_dev->bar0\_base) {

        return -EINVAL;

    }

    // 写魔术字到 DOORBELL 触发寄存器（触发硬件中断）

    spin\_lock(&db\_dev->lock);

    iowrite32(DOORBELL\_MAGIC\_VALUE, db\_dev->bar0\_base + PCIE\_DOORBELL\_TRIGGER);

    spin\_unlock(&db\_dev->lock);

    return 0;

}

// PCIe 设备初始化（探针函数）

static int pcie\_doorbell\_probe(struct pci\_dev \*pdev, const struct pci\_device\_id \*id) {

    struct pcie\_doorbell\_dev \*db\_dev;

    int ret, irq;

    // 1. 分配设备私有数据

    db\_dev = devm\_kzalloc(&pdev->dev, sizeof(\*db\_dev), GFP\_KERNEL);

    if (!db\_dev) return -ENOMEM;

    db\_dev->pdev = pdev;

    spin\_lock\_init(&db\_dev->lock);

    init\_waitqueue\_head(&db\_dev->wq);

    db\_dev->is\_triggered = false;

    // 2. 启用 PCIe 设备

    ret = pcim\_enable\_device(pdev);

    if (ret) return ret;

    // 3. 映射 BAR0 地址空间（DOORBELL 寄存器所在 BAR）

    db\_dev->bar0\_base = pcim\_iomap(pdev, 0, pci\_resource\_len(pdev, 0));

    if (!db\_dev->bar0\_base) return -ENODEV;

    // 4. 获取中断号并申请中断（MSI/MSI-X 优先）

    irq = pci\_alloc\_irq\_vectors(pdev, 1, 1, PCI\_IRQ\_MSI);

    if (irq < 0) return irq;

    ret = devm\_request\_irq(&pdev->dev, irq, pcie\_doorbell\_irq\_handler,

                          IRQF\_SHARED, "pcie-doorbell", db\_dev);

    if (ret) return ret;

    // 5. 保存私有数据到 PCI 设备

    pci\_set\_drvdata(pdev, db\_dev);

    dev\_info(&pdev->dev, "PCIe DOORBELL device initialized (irq: %d)", irq);

    return 0;

}

// PCIe 设备 ID 表（需根据实际硬件修改 Vendor ID/Device ID）

static const struct pci\_device\_id pcie\_doorbell\_id\_table\[\] = {

    { PCI\_DEVICE(0x1234, 0x5678) },  // 示例：厂商 ID=0x1234，设备 ID=0x5678

    { 0 }

};

MODULE\_DEVICE\_TABLE(pci, pcie\_doorbell\_id\_table);

// PCIe 驱动结构体

static struct pci\_driver pcie\_doorbell\_driver = {

    .name = "pcie-doorbell-driver",

    .id\_table = pcie\_doorbell\_id\_table,

    .probe = pcie\_doorbell\_probe,

};

module\_pci\_driver(pcie\_doorbell\_driver);

MODULE\_LICENSE("GPL");

MODULE\_DESCRIPTION("PCIe DOORBELL Synchronization Driver");

MODULE\_AUTHOR("Tech Developer");

核心逻辑解读

DOORBELL 触发机制：通过向 PCIE_DOORBELL_TRIGGER 寄存器写入魔术字，触发 PCIe 设备中断，实现主从设备同步。
中断同步：中断处理函数中通过自旋锁保护临界区，更新触发状态并唤醒等待队列，确保用户态/内核态线程能及时响应。
硬件适配：支持 MSI/MSI-X 中断（PCIe 推荐中断方式），寄存器地址和中断标志位需根据实际硬件手册修改。

关键注意事项

- 寄存器偏移、魔术字、中断标志位需与 PCIe 设备硬件手册严格一致。

- 若使用用户态编程，可通过 /dev 节点封装 pcie_doorbell_trigger 接口，配合 poll() 或 wait_event() 实现同步。

- 多设备场景需通过中断亲和性或设备树配置避免中断冲突。

三、用户态代码实现

用户态调试示例代码（C语言）

以下代码通过 /dev 设备节点与内核驱动交互，实现用户态触发 PCIe DOORBELL、等待中断响应的完整调试流程，适配 Linux 系统：


#include <stdio.h>  
#include <stdlib.h>  
#include <fcntl.h>  
#include <unistd.h>  
#include <sys/ioctl.h>  
#include <sys/wait.h>  
#include <signal.h>  

// 设备节点路径（需与内核驱动一致）  
#define DOORBELL\_DEV\_PATH "/dev/pcie\_doorbell"  

// IOCTL 命令定义（与内核驱动协商，示例：触发DOORBELL、查询状态）  
#define IOCTL\_TRIGGER\_DOORBELL \_IO('D', 0x01)  
#define IOCTL\_GET\_TRIGGER\_STATUS \_IOR('D', 0x02, int)  

// 信号处理函数（捕获中断唤醒信号）  
static void sig\_handler(int sig) {  
    printf("\[User Space\] Received DOORBELL interrupt signal (sig: %d)\\n", sig);  
}  

int main() {  
    int fd, ret, status;  
    pid\_t pid;  

    // 1. 注册信号处理函数（用于接收中断通知）  
    signal(SIGUSR1, sig\_handler);  

    // 2. 打开设备节点  
    fd = open(DOORBELL\_DEV\_PATH, O\_RDWR);  
    if (fd < 0) {  
        perror("open device failed");  
        return -1;  
    }  
    printf("\[User Space\] Open device %s successfully (fd: %d)\\n", DOORBELL\_DEV\_PATH, fd);  

    // 3. 创建子进程：父进程触发DOORBELL，子进程等待中断  
    pid = fork();  
    if (pid < 0) {  
        perror("fork failed");  
        close(fd);  
        return -1;  
    }  

    if (pid == 0) {  // 子进程：等待中断响应  
        printf("\[Child Process\] Waiting for DOORBELL interrupt...\\n");  
        pause();  // 阻塞等待信号（内核中断处理函数会发送SIGUSR1）  

        // 查询触发状态  
        ret = ioctl(fd, IOCTL\_GET\_TRIGGER\_STATUS, &status);  
        if (ret < 0) {  
            perror("ioctl get status failed");  
            exit(-1);  
        }  
        printf("\[Child Process\] DOORBELL trigger status: %s\\n", status ? "triggered" : "not triggered");  
        exit(0);  
    } else {  // 父进程：触发DOORBELL  
        sleep(1);  // 等待子进程准备就绪  
        printf("\[Parent Process\] Triggering PCIe DOORBELL...\\n");  

        // 触发DOORBELL（通过IOCTL调用内核接口）  
        ret = ioctl(fd, IOCTL\_TRIGGER\_DOORBELL);  
        if (ret < 0) {  
            perror("ioctl trigger doorbell failed");  
            close(fd);  
            return -1;  
        }  

        // 等待子进程退出  
        waitpid(pid, NULL, 0);  
        printf("\[Parent Process\] DOORBELL test completed\\n");  
    }  

    close(fd);  
    return 0;  
}

配套内核驱动补充（IOCTL 接口实现）

需在之前的内核驱动中添加 IOCTL 处理逻辑，使用户态能通过 ioctl() 调用内核功能：


// 内核驱动中添加 IOCTL 命令处理

#include <linux/ioctl.h>

// 与用户态一致的 IOCTL 命令定义

#define IOCTL\_TRIGGER\_DOORBELL \_IO('D', 0x01)

#define IOCTL\_GET\_TRIGGER\_STATUS \_IOR('D', 0x02, int)

// IOCTL 处理函数

static long pcie\_doorbell\_ioctl(struct file \*file, unsigned int cmd, unsigned long arg) {

    struct pcie\_doorbell\_dev \*db\_dev = file->private\_data;

    int ret = 0, status;

    spin\_lock(&db\_dev->lock);

    switch (cmd) {

        case IOCTL\_TRIGGER\_DOORBELL:

            // 调用内核态触发接口

            ret = pcie\_doorbell\_trigger(db\_dev);

            break;

        case IOCTL\_GET\_TRIGGER\_STATUS:

            // 读取触发状态并返回给用户态

            status = db\_dev->is\_triggered ? 1 : 0;

            if (copy\_to\_user((void \_\_user \*)arg, &status, sizeof(status))) {

                ret = -EFAULT;

            }

            break;

        default:

            ret = -ENOTTY;  // 不支持的命令

            break;

    }

    spin\_unlock(&db\_dev->lock);

    return ret;

}

// 文件操作结构体（补充 IOCTL 接口）

static const struct file\_operations pcie\_doorbell\_fops = {

    .owner = THIS\_MODULE,

    .open = pcie\_doorbell\_open,

    .release = pcie\_doorbell\_release,

    .unlocked\_ioctl = pcie\_doorbell\_ioctl,

};

// 设备节点创建（在 probe 函数末尾添加）

static int pcie\_doorbell\_probe(struct pci\_dev \*pdev, const struct pci\_device\_id \*id) {

    // ... 之前的初始化逻辑 ...

    // 注册字符设备（主设备号动态分配）

    ret = alloc\_chrdev\_region(&devno, 0, 1, "pcie-doorbell");

    if (ret < 0) return ret;

    cdev\_init(&db\_dev->cdev, &pcie\_doorbell\_fops);

    db\_dev->cdev.owner = THIS\_MODULE;

    ret = cdev\_add(&db\_dev->cdev, devno, 1);

    if (ret < 0) return ret;

    // 创建类和设备节点（用户态可见）

    db\_dev->class = class\_create(THIS\_MODULE, "pcie-doorbell-class");

    device\_create(db\_dev->class, &pdev->dev, devno, NULL, "pcie\_doorbell");

    return 0;

}

四、代码调试

1、正常运行结果说明（预期输出）

1）编译与加载驱动阶段

# 内核驱动编译（Makefile 执行后）

make -C /lib/modules/$(uname -r)/build M=$(PWD) modules

# 加载驱动

insmod pcie_doorbell.ko

# 查看驱动加载状态与中断号

dmesg | grep "pcie-doorbell"

# 预期输出：

[12345.678901] PCIe DOORBELL device initialized (irq: 56) # 中断号随系统分配

ls /dev/pcie_doorbell # 确认设备节点创建

# 预期输出：/dev/pcie_doorbell

2）编译用户态程序
gcc user_doorbell.c -o user_doorbell
# 运行程序（需 root 权限）
sudo ./user_doorbell
# 预期输出：
[User Space] Open device /dev/pcie_doorbell successfully (fd: 3)
[Child Process] Waiting for DOORBELL interrupt...
[Parent Process] Triggering PCIe DOORBELL...
[User Space] Received DOORBELL interrupt signal (sig: 10) # SIGUSR1 信号
[Child Process] DOORBELL trigger status: triggered
[Parent Process] DOORBELL test completed

3）代码运行结果解读

4）调试结果说明

4-1）正常场景调试验证（确认功能有效性）

4-2）异常场景调试结果与问题定位

4-3）并发场景调试结果（验证安全性）

# 同时运行 2 个用户态程序（模拟并发）

sudo ./user_doorbell &

# 预期输出：

两个程序均正常执行，无死锁、无状态错乱，均输出 "triggered"

# 内核日志验证（无竞争条件报错）

dmesg | grep -i "lock" # 无自旋锁相关报错

- 说明：内核态自旋锁有效保护临界区，避免多进程并发访问 is_triggered 状态时出现数据竞争。

五、核心调试工具与日志解读

1. 内核态调试工具

- dmesg ：查看驱动初始化、中断处理、错误信息（如寄存器读写失败、中断清除异常）。

- cat /proc/interrupts ：验证中断是否被触发（对应中断号的计数是否递增）。

- lspci -vvv ：查看 PCIe 设备中断模式（MSI/MSI-X 是否启用）、BAR 地址分配是否与驱动一致。

2. 用户态调试工具

- strace ./user_doorbell ：跟踪系统调用（ open / ioctl / pause ），确认是否调用成功（返回值非负）。

- gdb ./user_doorbell ：断点调试（如在 ioctl 调用后断点，查看 status 变量值是否正确）。

3. 关键错误日志解读

谢谢关注，后续会持续分享关于AI,GPU,Linux开发,操作系统，图形学，高性能计算，芯片行业讯息。欢迎感兴趣的伙伴关注微信公众号参与讨论沟通:

*********************

请关注微信公众号:颇锐克科技共享

*********************

你好啊，陌生人

版块导航

快捷功能区

基于PCIe doorbell同步的系统软件实现

一、基于Doorbell同步机的软件设计

二、PCIe DOORBELL 同步实现代码（Linux 内核态）

三、用户态代码实现

最新回复 (0)

你好啊，陌生人

快捷功能区

基于PCIe doorbell同步的系统软件实现

一、基于Doorbell同步机的软件设计

二、PCIe DOORBELL 同步实现代码（Linux 内核态）

三、用户态代码实现

最新回复 (0)

加入讨论

你好啊，陌生人

快捷功能区

所有板块