引言

在 Linux 的世界中,显示子系统是最复杂的子系统之一。它需要管理 GPU 的 3D 渲染管线、多显示器的分辨率设置、垂直同步(VSync)、多平面叠加(Plane)、以及跨进程的显存共享。这一切都依赖于 DRM (Direct Rendering Manager) 和 KMS (Kernel Mode Setting) 两个核心子系统。

与现代 Wayland/X11 显示服务器不同,DRM/KMS 在内核态完成关键的资源管理和模式切换,这意味着:

  • 系统启动早期即可通过 KMS 设置帧缓冲(Framebuffer),实现平滑的开机动画
  • 多应用共享 GPU 时,DRM 提供权限隔离和内存保护
  • Atomic Mode Setting 保证多参数变更的原子性,彻底消除屏幕闪烁

本文将深入拆解 DRM/KMS 的四层架构模型,通过一个 MiniDRM 驱动开发实例完整展示 GPU 驱动的实现细节,并探讨现代渲染栈(Vulkan/OpenGL/VAAPI)如何通过 DRM 与内核交互。

DRM 架构总览

DRM 子系统通过三层对象模型抽象 GPU 硬件。理解下面这张架构图是阅读 DRM 源码的前提:

┌─────────────────────────────────────────────────────────────────┐
│                    DRM 子系统架构层次图                           │
├─────────────────────────────────────────────────────────────────┤
│  用户空间:  X11 / Wayland / Vulkan / OpenGL / VAAPI / GStreamer │
│                │                                                │
│           libdrm (libdrm.so)                                    │
│                │                                                │
│  内核空间:  ┌────────────────────────────────┐                  │
│            │  VFS 层  →  /dev/dri/cardX     │                  │
│            │          →  /dev/dri/renderD128│                   │
│            │  GEM 层  → 显存分配            │                   │
│            │  KMS 层  → 模式设置            │                   │
│            │  Fence 层 → 同步原语           │                   │
│            │  Scheduler → GPU 调度          │                   │
│            └────────────────────────────────┘                   │
│                                                                  │
│  硬件层:     GPU 寄存器 → 命令流 → 显存                         │
└─────────────────────────────────────────────────────────────────┘

核心数据结构

DRM 通过一组关键对象描述硬件拓扑,每个硬件模块都有对应的数据结构:

对象 职责 形象理解
struct drm_device DRM 设备实例,驱动注册入口 驱动核心结构
struct drm_driver 驱动操作函数表(ioctl 分发) 驱动方法表
struct drm_crtc CRT 控制器:时序生成、扫描输出 画布管理器
struct drm_encoder 编码器:像素流到信号电平转换 翻译器
struct drm_connector 连接器:物理输出端口(HDMI/eDP/DP) 插座
struct drm_plane 显示平面:图层叠加(Cursor/Primary/Overlay) 图层
struct drm_framebuffer 帧缓冲:像素数据的抽象 画布
struct drm_gem_object GEM 对象:GPU 显存块 显存块

KMS 的数据流路径

KMS (Kernel Mode Setting) 在早期 Linux 中由用户空间(X Server)完成分辨率设置。KMS 将这些行为移入内核后,带来了无闪烁切换、安全隔离和多应用并发三大优势:

用户空间                             内核空间
   │                                   │
   ├── KMS Atomic Commit ─────────────→│ drm_mode_atomic_ioctl()
   │    (DRM_MODE_ATOMIC_CRTC_MODEID   │         │
   │     DRM_MODE_ATOMIC_CONNECTOR)    │ drm_atomic_commit()
   │                                   │         │
   │                                   │         ├─ drm_atomic_check_plane()
   │                                   │         ├─ drm_atomic_check_crtc()
   │                                   │         └─ drm_atomic_check_connector()
   │                                   │         │
   │                                   │         ├─ plane->atomic_update()    ← 写入寄存器
   │                                   │         ├─ crtc->atomic_enable()     ← 时序发生器
   │                                   │         └─ encoder->atomic_enable()  ← 信号编码
   │                                   │         │
   │                                   │         └─ drm_crtc_vblank_on()      ← VBlank 中断
   │                                   │

GEM 显存管理

Graphics Execution Manager (GEM) 是 DRM 的子模块,负责 GPU 显存的分配、映射和共享。

DMA-BUF 显存共享

现代 Linux 显示栈中,零拷贝跨驱动共享是性能的关键。DMA-BUF 实现了 GPU 显存的跨进程、跨驱动共享:

// 导出 DMA-BUF(生产者,例如 GPU 驱动)
struct dma_buf_export_info exp_info = {
    .exp_name = "MYGPU",
    .owner    = THIS_MODULE,
    .ops      = &mygem_buf_ops,
    .size     = size,
    .flags    = O_RDWR,
    .resv     = resv,
};
struct dma_buf *dmabuf = dma_buf_export(&exp_info);

// 获得文件描述符(可传递给 Wayland compositor 或视频解码器)
int fd = dma_buf_fd(dmabuf, O_CLOEXEC);

典型场景:视频解码器(如 VAAPI)解码一帧后,通过 DMA-BUF 文件描述符传递给 DRM KMS Plane,无需拷贝像素数据。

GEM 对象生命周期

每个 GEM 对象在 DRM 子系统中维护引用计数和映射表:

// 驱动侧 GEM 操作表
static const struct drm_gem_object_funcs mygem_obj_funcs = {
    .free  = mygem_free_object,    // 释放回调
    .open  = mygem_object_open,    // PRIME 导入时调用
    .close = mygem_object_close,
    .export = mygem_prime_export,  // DMA-BUF 导出
};

// dumb buffer 是最简单的 GMM 分配类型(CPU 可访问)
static int mygem_create_dumb(struct drm_file *file,
                              struct drm_device *dev,
                              struct drm_mode_create_dumb *args)
{
    // 分配物理连续内存(适合简单 SoC 显示控制器)
    // 对于 GPU,使用 tiling 压缩后会改为 GEM SHMEM 或 PRIME
}

实战:MiniDRM 驱动开发

下面我们实现一个最小化的 DRM/KMS 驱动(基于 Linux 6.6+ 的 drm_simple_kms_helper),实现一个虚拟的 VESA 兼容输出,完整展示 KMS 驱动的四个核心回调:

1. 驱动主体结构

// minimrm.c - 最小 DRM/KMS 驱动示例
#include <drm/drm_drv.h>
#include <drm/drm_atomic.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_gem_framebuffer_helper.h>
#include <drm/drm_gem_dma_helper.h>
#include <drm/drm_simple_kms_helper.h>
#include <drm/drm_module.h>

#define MINIMRM_WIDTH   1920
#define MINIMRM_HEIGHT  1080
#define MINIMRM_BPP       32

// MiniRM 私有设备数据
struct minimrm_device {
    struct drm_device                 drm;
    struct drm_simple_display_pipe    pipe;
    struct drm_connector              connector;
    void __iomem                     *mmio;     // 模拟 MMIO 区域
    struct drm_display_mode           mode;
};

static inline struct minimrm_device *
drm_to_minimrm(struct drm_device *drm)
{
    return container_of(drm, struct minimrm_device, drm);
}

static const uint32_t minimrm_formats[] = {
    DRM_FORMAT_XRGB8888,
    DRM_FORMAT_ARGB8888,
};

2. CRTC 回调(时序控制器)

CRTC 是 KMS 的核心,负责生成像素扫描时序(HSync/VSync/Pixel Clock)并将像素流发送给 Encoder:

static void minimrm_crtc_enable(struct drm_simple_display_pipe *pipe,
                                 struct drm_crtc_state *crtc_state)
{
    struct minimrm_device *m_dev = drm_to_minimrm(pipe->crtc.dev);
    struct drm_crtc *crtc = &pipe->crtc;

    // 写入时序寄存器(模拟)
    iowrite32(MINIMRM_WIDTH,      m_dev->mmio + HSync_START);
    iowrite32(MINIMRM_HEIGHT,     m_dev->mmio + VSync_START);
    iowrite32(MINIMRM_WIDTH * 4,  m_dev->mmio + PITCH_REG);
    iowrite32(0x01,               m_dev->mmio + CRTC_ENABLE);

    // 启用 VBlank 中断(用于页面翻转同步)
    drm_crtc_vblank_on(crtc);
}

static void minimrm_crtc_disable(struct drm_simple_display_pipe *pipe)
{
    struct minimrm_device *m_dev = drm_to_minimrm(pipe->crtc.dev);

    iowrite32(0x00, m_dev->mmio + CRTC_ENABLE);
    drm_crtc_vblank_off(&pipe->crtc);
}

3. Plane 回调(图层与帧缓冲绑定)

Plane 是 KMS 中最令人困惑的概念。每个 Plane 代表一个独立的图层(Layer),Framebuffer 被绑定到 Plane 上而非直接绑定到 CRTC。典型的硬件有 2-4 个 Plane:

  • Primary Plane:必须存在,承载主画面(桌面/窗口管理器)
  • Cursor Plane:用于硬件光标叠加(alpha blending 硬件支持)
  • Overlay Plane:视频叠加层,支持色彩空间转换和缩放
void minimrm_pipe_update(struct drm_simple_display_pipe *pipe,
                          struct drm_plane_state *old_state)
{
    struct drm_plane_state *state = pipe->plane.state;
    struct drm_framebuffer *fb = state->fb;
    struct minimrm_device *m_dev = drm_to_minimrm(pipe->crtc.dev);

    if (fb) {
        // 从 Framebuffer 提取 DMA 地址并写入扫描输出寄存器
        struct drm_gem_dma_object *dma_obj;

        dma_obj = drm_fb_dma_get_gem_obj(fb, 0);

        // 写入 frame-buffer 的 DMA 物理地址
        iowrite32(lower_32_bits(dma_obj->dma_addr),
                  m_dev->mmio + FB_ADDRESS_LO);
        iowrite32(upper_32_bits(dma_obj->dma_addr),
                  m_dev->mmio + FB_ADDRESS_HI);
        iowrite32(MINIMRM_WIDTH * MINIMRM_BPP / 8,
                  m_dev->mmio + FB_PITCH);
    }
}

4. 连接器与模式枚举

Connector 代表物理输出接口(HDMI、eDP、DP 等)。当用户插拔显示器时,驱动通过 drm_connector_helper_hpd_irq_event() 触发中断,重新检测 EDID:

// 读取显示器的 EDID 并返回支持的分辨率列表
static int minimrm_connector_get_modes(struct drm_connector *connector)
{
    struct drm_display_mode *mode;

    mode = drm_mode_create(connector->dev);
    if (!mode)
        return -ENOMEM;

    mode->hdisplay    = MINIMRM_WIDTH;
    mode->hsync_start = MINIMRM_WIDTH + 88;
    mode->hsync_end   = MINIMRM_WIDTH + 88 + 44;
    mode->htotal      = MINIMRM_WIDTH + 88 + 44 + 148;

    mode->vdisplay    = MINIMRM_HEIGHT;
    mode->vsync_start = MINIMRM_HEIGHT + 4;
    mode->vsync_end   = MINIMRM_HEIGHT + 4 + 5;
    mode->vtotal      = MINIMRM_HEIGHT + 4 + 5 + 36;

    mode->vrefresh    = 60;
    mode->clock       = mode->htotal * mode->vtotal * 60 / 1000;
    mode->type        = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;

    drm_mode_set_name(mode);
    drm_mode_probed_add(connector, mode);

    return 1;
}

// 连接器状态检测(用于 DPMS / 热插拔)
static enum drm_connector_status
minimrm_connector_detect(struct drm_connector *connector, bool force)
{
    // 读取 HPD(Hot Plug Detect)GPIO 状态
    return connector_status_connected;
}

驱动注册入口

static const struct drm_simple_display_pipe_funcs minimrm_pipe_funcs = {
    .enable      = minimrm_crtc_enable,
    .disable     = minimrm_crtc_disable,
    .update      = minimrm_pipe_update,
    .prepare_fb  = drm_gem_simple_display_pipe_prepare_fb,
};

static struct drm_driver minimrm_driver = {
    .driver_features   = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,
    .fops              = &drm_driver_fops,       // 来自 drm_drv.h 的通用 fops
    .name              = "minimrm",
    .desc              = "Mini DRM/KMS Test Driver",
    .date              = "20240930",
    .major             = 1,
    .minor             = 0,
    .gem_create_object = minimrm_gem_create_object,
};

static int minimrm_probe(struct platform_device *pdev)
{
    struct minimrm_device *m_dev;
    struct drm_device *drm;
    int ret;

    m_dev = devm_drm_dev_alloc(&pdev->dev, &minimrm_driver,
                                struct minimrm_device, drm);
    if (IS_ERR(m_dev))
        return PTR_ERR(m_dev);

    drm = &m_dev->drm;

    // 初始化 simple display pipe
    // 内部完成 crtc/encoder/connector/plane 的标准注册
    ret = drm_simple_display_pipe_init(drm, &m_dev->pipe,
                                        &minimrm_pipe_funcs,
                                        minimrm_formats,
                                        ARRAY_SIZE(minimrm_formats),
                                        NULL,
                                        &m_dev->connector);
    if (ret)
        return ret;

    drm_mode_config_reset(drm);

    // 注册 DRM 设备(创建 /dev/dri/cardX 和 /dev/dri/renderD128)
    ret = drm_dev_register(drm, 0);
    if (ret)
        return ret;

    // 初始化 fbdev 模拟:确保系统启动期间有控制台输出
    drm_fbdev_generic_setup(drm, MINIMRM_BPP);

    platform_set_drvdata(pdev, drm);
    return 0;
}

VSync 与 Fence 同步

DMA-FENCE 机制

现代显示栈需要精确同步 GPU 渲染完成与显示扫描输出,避免撕裂(Tearing)。DMA-FENCE 提供了跨设备、跨上下文的同步:

// GPU 驱动侧:渲染命令提交时获取 in_fence,渲染完成时 signal out_fence
void gpu_job_complete(struct gpu_job *job)
{
    dma_fence_signal(job->out_fence);  // 通知显示控制器可以翻页
}

// KMS 驱动侧:atomic commit 时等待 in_fence signal
// (由 DRM 核心自动处理,驱动编写者几乎不需要关心)

VBlank 事件处理

KMS 通过 VBlank 中断驱动事件的精确投递(例如用户在某个 VBlank 时刻希望收到通知):

// VBlank 中断处理程序
static irqreturn_t minimrm_irq_handler(int irq, void *arg)
{
    struct drm_device *drm = arg;
    struct drm_crtc *crtc;
    unsigned long flags;

    drm_for_each_crtc(crtc, drm) {
        flags = drm_crtc_vblank_lock(crtc);

        drm_crtc_handle_vblank(crtc);

        // 发送用户空间请求的 VBlank 事件(用于精确帧调度)
        if (crtc->state->event) {
            drm_crtc_send_vblank_event(crtc, crtc->state->event);
            crtc->state->event = NULL;
            crtc->state->active = true;
        }

        drm_crtc_vblank_unlock(crtc, flags);
    }
    return IRQ_HANDLED;
}

用户空间通过 drm_wait_vblank ioctl 阻塞等待特定 VBlank 计数,典型的游戏/视频播放器利用此接口实现无撕裂的帧呈现。

Render 节点与权限隔离

现代 DRM 分离两种设备节点以支持权限隔离:

/dev/dri/card0      → 主节点:KMS 模式设置特权操作
                       (需要 root 或 video 组成员权限)

/dev/dri/renderD128 → 渲染节点:仅提交渲染命令
                       (允许非特权用户提交 GPU 计算)
// 在 driver_features 中标记支持渲染节点
.driver_features = DRIVER_RENDER | DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC

权限分离的意义:Wayland compositor 通过主节点控制显示模式(特权操作),而 Vulkan/OpenGL 应用只需渲染节点即可完成 3D 渲染——两者互不干扰。恶意程序即使能访问渲染节点,也无法修改全局显示配置。

现代显示栈全景

理解 DRM/KMS 的位置需要看整个 Linux 图形栈的层次:

┌──────────────────────────────────────────────────────────────────┐
│                         用户空间                                  │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────────────┐   │
│  │  Wayland     │  │  Vulkan      │  │  OpenGL / Mesa / GBM│    │
│  │  Compositor  │  │  Loader      │  │  Gallium / RADV     │    │
│  └──────┬───────┘  └──────┬───────┘  └──────────┬───────────┘   │
│         └─────────────────┼──────────────────────┘               │
│                           │                                      │
│                    ┌──────┴───────┐                              │
│                    │   libdrm     │                              │
│                    └──────┬───────┘                              │
└───────────────────────────┼──────────────────────────────────────┘
                            │
┌───────────────────────────┼──────────────────────────────────────┐
│                      内核 DRM/KMS                                │
│                           │                                      │
│  ┌────────────┐  ┌────────┴───────┐  ┌────────────────────────┐ │
│  │ i915 / xe  │  │   amdgpu       │  │  nouveau / nova       │ │
│  │ Intel GPU  │  │   AMD GPU      │  │  NVIDIA                │ │
│  └────────────┘  └────────────────┘  └────────────────────────┘ │
│                                                                   │
│  ┌────────────┐  ┌────────────────┐  ┌────────────────────────┐ │
│  │ v3d / vc4  │  │   panfrost     │  │  Etnaviv / Lima       │ │
│  │ Broadcom   │  │   Mali Midgard │  │  Vivante / Mali       │ │
│  └────────────┘  └────────────────┘  └────────────────────────┘ │
└──────────────────────────────────────────────────────────────────┘

生产环境调优建议

1. Atomic Mode Setting 是必不可少的

老的 legacy API(drm_mode_crtc_setplane、drm_mode_setcrtc)存在竞态条件,在多 Plane 场景下会导致闪烁。确保驱动支持 DRIVER_ATOMIC 并使用统一的原子提交流:

# 查看 KMS 能力
modetest -M <driver>    # 来自 libdrm 的测试工具

# 验证 atomic caps
cat /sys/kernel/debug/dri/0/state | grep -i atomic

2. DMA-BUF 同步文件 (Sync File) 优化

Linux 6.8+ 之前,跨驱动 DMA-BUF 同步的隐式模式存在严重的生产问题(部分旧内核会导致死锁)。建议驱动显式导出 sync_file:

// 显式同步 API(推荐)
struct dma_sync_export export = {
    .flags = DMA_SYNC_READ | DMA_SYNC_WRITE,
};
dma_buf_export_sync_file(dmabuf, &export);

// 对比隐式同步(auto-signal on release,6.8 前常用)
// 在新内核中已废弃

3. 调试与监控

# 启用 DRM 子系统的内核调试日志
echo 0x1f > /sys/module/drm/parameters/debug

# 查看当前 KMS 状态(所有 object 链表)
cat /sys/kernel/debug/dri/0/state

# 查看各 Plane 和 CRTC 分配
cat /sys/kernel/debug/dri/0/framebuffer

# 模拟模式测试
modetest -M amdgpu -s 33:1920x1080 -D 0

4. 强制视频模式与 EDID 注入

当显示器 EDID 损坏时,可在内核 cmdline 中强制指定:

video=HDMI-A-1:1920x1080@60D

或通过 sysfs 动态覆盖:

echo 1920x1080@60 > /sys/class/drm/card0-HDMI-A-1/mode

总结

Linux DRM/KMS 子系统是一个功能完备的显示管理框架,通过以下五个核心设计实现现代 GPU 驱动:

  • 分层对象模型:CRTC/Encoder/Connector/Plane 清晰表达硬件拓扑,支持从单显到多显的灵活配置
  • Atomic Mode Setting:所有配置变更通过 DRM_IOCTL_MODE_ATOMIC 检查后原子应用,消除竞态闪烁
  • DMA-BUF:零拷贝跨驱动显存共享,是视频解码器、合成器和 GPU 渲染多方协作的基础
  • Fence 语义:精确同步 GPU 渲染与显示扫描输出,避免画面撕裂和时序错误
  • Render 节点:提供精细化的权限隔离,让非特权应用安全使用 GPU 计算

对 GPU 驱动开发者而言,善用 drm_simple_kms_helper 可以快速搭建基础驱动框架。但对系统程序员而言,理解 DRM/KMS 的交互流程是调试显示问题、优化 GPU 性能的基础。在 Wayland 和 Linux 桌面生态快速发展的背景下,DRM/KMS 作为用户态显示协议的底层支撑,对全栈系统工程师的长远发展具有重要价值。

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论
立即
投稿

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部