GPU 서브시스템 (DRM/KMS)

Linux GPU 서브시스템(DRM/KMS)을 디스플레이 파이프라인(Pipeline)과 연산 가속 경로를 함께 보는 관점에서 심층 분석합니다. DRM core와 KMS 객체 모델(CRTC/plane/encoder/connector), GEM/TTM 메모리 관리(Memory Management)자, DMA-BUF 기반 장치 간 버퍼(Buffer) 공유, atomic modesetting과 vblank 동기화, fence 기반 GPU 작업 순서 제어, 전원·클럭·열 관리(Thermal Management), userspace(Mesa/Wayland)와의 ioctl 계약, debugfs/tracepoint로 프레임 드롭과 hang을 진단하는 방법까지 GPU 드라이버 개발 핵심을 다룹니다.

세부 문서 안내

GPU 서브시스템 문서는 주제별로 3개의 세부 문서로 나뉘어 있습니다. 각 문서에서 해당 영역을 심층적으로 다룹니다.

DRM 서브시스템 구조 개요

DRM은 Linux 커널의 GPU 접근을 관리하는 서브시스템입니다. 원래 3D 그래픽 가속을 위해 도입되었으나, 현재는 디스플레이 출력(KMS), GPU 메모리 관리(GEM/TTM), GPU 작업 스케줄링까지 포괄하는 핵심 프레임워크로 발전했습니다.

디바이스 노드와 권한 모델 요약

현대 DRM UAPI는 GPU 하나를 단일 문자 디바이스로만 노출하지 않습니다. 같은 하드웨어라도 화면 제어, 비특권 렌더링, 비그래픽 연산을 서로 다른 노드로 나누어 권한 경계와 사용자 공간(User Space) 스택을 분리합니다.

디바이스 노드의 상세 구조와 권한 모델, drm_file 구조체(Struct), DRM master 개념 등은 DRM 코어 및 디스플레이 — 디바이스 노드와 권한 모델 섹션을 참고하세요.

DRM 아키텍처

각 계층의 상세 내용은 다음 문서에서 확인할 수 있습니다:

• KMS (Mode Setting) → DRM 코어 및 디스플레이 — KMS
• GEM / TTM / DMA-BUF → GPU 메모리 관리 및 스케줄러
• GPU Scheduler → GPU 스케줄러 (drm_sched)
• GPU 컴퓨트 (GPGPU) → GPU 컴퓨팅

DRM 코어 초기화 및 드라이버 등록

DRM 드라이버는 PCI 디바이스 탐지 → 리소스 할당 → 커널 등록 → 사용자 공간 노출의 단계를 거칩니다. 이 섹션에서는 drm_driver 구조체의 핵심 필드와 초기화 흐름을 실제 커널 소스 코드와 함께 설명합니다.

drm_driver 구조체 핵심 필드

struct drm_driver는 DRM 드라이버의 모든 동작을 정의하는 핵심 구조체입니다. 다음은 2025 년 기준 주요 필드입니다:

/* include/drm/drm_drv.h — drm_driver 구조체 (핵심 필드) */
struct drm_driver {
    /* 드라이버 메타데이터 */
    const char *name;              /* 드라이버 이름 (예: "i915", "amdgpu") */
    const char *desc;              /* 설명 문자열 */
    const char *date;              /* 버전/날짜 */
    const struct file_operations *fops; /* 파일 오퍼레이션 */

    /* 드라이버 기능 플래그 */
    u32 driver_features;         /* DRIVER_GEM, DRIVER_MODESET, DRIVER_RENDER 등 */

    /* IOCTL 테이블 — 사용자 공간 API 노출 */
    const struct drm_ioctl_desc *ioctls;
    int num_ioctls;

    /* PCI 디바이스 테이블 — 자동 탐지용 */
    const struct pci_device_id *pci_driver;

    /* 콜백 함수들 — 드라이버 수명주기 */
    int (*load)(struct drm_device *, unsigned long flags);
    void (*unload)(struct drm_device *);
    int (*open)(struct drm_device *, struct drm_file *);
    void (*postclose)(struct drm_device *, struct drm_file *);

    /* KMS 관련 함수 포인터 */
    const struct drm_mode_config_funcs *mode_config_funcs;
    const struct drm_mode_config_helper_funcs *mode_config_helpers;

    /* GEM/메모리 관리 함수 */
    const struct drm_gem_object_funcs *gem_object_funcs;
    const struct ttm_place *placements;  /* TTM 메모리 영역 */

    /* 동기화 및 스케줄링 */
    const struct drm_sched_driver *sched_driver;  /* drm_sched ops */

    /* 디버깅 및 정보 제공 */
    void (*debugfs_init)(struct drm_minor *);
    int (*gem_prime_pin)(struct drm_gem_object *obj);
};

PCI Probe — 디바이스 탐지 및 초기화

대부분의 GPU 드라이버는 PCI 서브시스템을 통해 탐지됩니다. 다음은 amdgpu 드라이버의 실제 probe 함수입니다:

/* drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c — PCI probe 함수 */
static int
amdgpu_pci_probe(struct pci_dev *pdev,
                 const struct pci_device_id *ent)
{
    struct drm_device *ddev;
    struct amdgpu_device *adev;
    int ret;

    /* 1. DRM 디바이스 할당 */
    ddev = devm_drm_dev_alloc(&pdev->dev, &amdgpu_kms_driver,
                               struct amdgpu_device, ddev);
    if (IS_ERR(ddev))
        return PTR_ERR(ddev);

    adev = drm_to_adev(ddev);
    adev->ddev = ddev;
    adev->pdev = pdev;
    pci_set_drvdata(pdev, adev);

    /* 2. PCI 리소스 활성화 */
    ret = pci_enable_device(pdev);
    if (ret < 0) {
        dev_err(&pdev->dev, "Cannot enable PCI device\n");
        return ret;
    }

    /* 3. MMIO 리소스 매핑 */
    adev->rmmio = pci_iomap(pdev, 0, 0);
    if (!adev->rmmio) {
        dev_err(&pdev->dev, "Cannot map MMIO region\n");
        ret = -ENOMEM;
        goto err_disable_pci;
    }

    /* 4. DRM 디바이스 등록 (사용자 공간에 /dev/dri/cardN 노출) */
    ret = drm_dev_register(ddev, 0);
    if (ret)
        goto err_unmap_mmio;

    /* 5. 추가 초기화 (펌웨어 로드, 파워 관리 등) */
    ret = amdgpu_device_init(adev);
    if (ret)
        goto err_unregister;

    return 0;

err_unregister:
    drm_dev_unregister(ddev);
err_unmap_mmio:
    pci_iounmap(pdev, adev->rmmio);
err_disable_pci:
    pci_disable_device(pdev);
    return ret;
}

drm_device 구조체와 수명주기

struct drm_device는 DRM 코어가 관리하는 디바이스 컨텍스트입니다:

/* include/drm/drm_device.h — drm_device 구조체 (핵심 필드) */
struct drm_device {
    /* 디바이스 식별 */
    struct device *dev;           /* Linux device 모델 */
    struct drm_driver *driver;    /* 드라이버 ops */

    /* KMS 객체 관리 */
    struct drm_mode_config mode_config;  /* CRTC/encoder/connector/plane 목록 */

    /* 메모리 관리 */
    struct drm_gem_object *gem_object_list;
    struct mutex gem_mutex;

    /* 파일/클라이언트 관리 */
    struct list_head filelist;
    struct drm_file *file_idr;

    /* 마스터 권한 — 인증된 클라이언트만 KMS 제어 */
    struct drm_master *master;

    /* 스케줄러 */
    struct drm_gpu_scheduler *sched[DRM_GPU_SCHED_MAX_ENTITIES];

    /* 디버깅 */
    struct drm_minor *primary;
    struct drm_minor *render;
};

커맨드 서브미션 (Command Submission)

GPU 에 작업을 지시하려면 사용자 공간이 커맨드 버퍼 (Command Buffer) 를 작성하여 커널에 제출 (Submit) 합니다. 커널은 이를 검증 후 GPU 의 링 버퍼 (Ring Buffer) 에 기록하고, GPU 가 자동으로 처리합니다.

링 버퍼 아키텍처

링 버퍼는 순환 큐 (Circular Queue) 구조로, CPU(프로듀서) 가 커맨드를 쓰고 GPU(컨슈머) 가 읽어서 실행합니다.

/* drivers/gpu/drm/amd/amdgpu/amdgpu_ring.h — 링 버퍼 구조체 */
struct amdgpu_ring {
    struct amdgpu_device *adev;
    unsigned enum amd_ip_block_type type;  /* GFX, SDMA, Compute 등 */
    const struct amdgpu_ring_funcs *funcs;

    u32 *ring;                    /* 링 버퍼 포인터 (VRAM/GTT 매핑) */
    unsigned long gpu_addr;         /* GPU 가 보는 주소 */
    u32 wptr;                     /* Write Pointer — CPU 가 쓴 위치 */
    u32 rptr;                     /* Read Pointer — GPU 가 읽은 위치 */
    u32 count_dw;                 /* 현재 커맨드 DW (DWORD) 수 */
    u32 max_dw;                   /* 최대 커맨드 크기 */
    u32 ring_size;                /* 링 버퍼 크기 (바이트) */

    struct mutex mutex;           /* 직렬화용 뮤텍스 */
    bool ready;                   /* 링 사용 가능 여부 */

    /* 스케줄러 연동 */
    struct drm_sched_rq *sched_rq;
    struct drm_gpu_scheduler *sched;
};

Indirect Buffer (IB) — 간접 커맨드 버퍼

복잡한 워크로드는 여러 개의 Indirect Buffer(IB) 로 구성됩니다. 각 IB 는 GPU 가 실행할 커맨드 시퀀스를 담으며, 메인 링 버퍼는 IB 를 체이닝합니다.

Fence 와 동기화

Fence 는 GPU 작업의 완료를 나타내는 동기화 프리미티브입니다. DMA Fence 는 커널 내부에서, Sync File 은 사용자 공간에서 사용됩니다.

/* include/linux/dma-fence.h — DMA Fence 구조체 */
struct dma_fence {
    refcount_t refcount;         /* 참조 카운트 */
    spinlock_t lock;             /* 상태 보호용 스핀락 */
    unsigned long flags;         /* FLAG_SIGNALED 등 */
    int status;                  /* 0: 성공, -errno: 실패 */

    /* Fence 식별자 */
    u64 seqno;                   /* 시퀀스 번호 */
    u32 context;                 /* 컨텍스트 ID */

    /* 콜백 */
    struct rcu_head rcu;
    const struct dma_fence_ops *ops;
};

/* Fence 시그널 (완료 알림) */
static inline void
dma_fence_signal(struct dma_fence *fence)
{
    if (!test_and_set_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags))
        __dma_fence_signal(fence);
}

GPU 인터럽트 처리

GPU 는 작업 완료, 오류, VBlank(수직 귀선 소거), thermal 이벤트 등을 커널에 알리기 위해 인터럽트 (Interrupt) 를 사용합니다. 현대 GPU 는 수백 개의 인터럽트 소스를 가지며, 이를 효율적으로 처리하기 위해 MSI-X(Message Signaled Interrupts) 와 인터럽트 도메인을 활용합니다.

GPU 인터럽트 종류

인터럽트 핸들러(Handler) 아키텍처

GPU 인터럽트 처리는 Top Half(하드 IRQ) 와 Bottom Half(스레디드 IRQ) 로 나뉩니다:

• Top Half — 최소한의 긴급 작업만 수행 (레지스터(Register) 읽기, 인터럽트 소스 식별), spin_lock 으로 보호
• Bottom Half — 실제 처리 (Fence 시그널, 에러 로깅, 스케줄러 웨이크업), kthread 컨텍스트에서 실행

/* drivers/gpu/drm/amd/amdgpu/amdgpu_irq.c — AMDGPU 인터럽트 핸들러 */
static irqreturn_t
amdgpu_irq_handler(int irq, void *dev_id)
{
    struct amdgpu_device *adev = dev_id;
    u32 status;

    /* 1. 인터럽트 소스 식별 (MMIO 레지스터 읽기) */
    status = RREG32_SOC15(GC, 0, mmGC_INT_CNTL);

    /* 2. 처리할 인터럽트가 없으면 IRQ_NONE 반환 */
    if (!(status & GC_INT_MASK))
        return IRQ_NONE;

    /* 3. 인터럽트 소스 클리어 (Ack) */
    WREG32_SOC15(GC, 0, mmGC_INT_ACK, status);

    /* 4. 스레디드 IRQ 깨우기 (Bottom Half) */
    wake_up_interruptible(&adev->irq_thread_wq);

    return IRQ_WAKE_THREAD;
}

/* 스레디드 인터럽트 핸들러 (Bottom Half) */
static irqreturn_t
amdgpu_irq_thread(int irq, void *dev_id)
{
    struct amdgpu_device *adev = dev_id;

    /* 5. Fence 시그널, 에러 처리, 스케줄러 알림 등 */
    amdgpu_fence_process(adev);
    amdgpu_dm_irq_process(adev);  /* 디스플레이 IRQ */
    amdgpu_ras_process(adev);     /* 오류 처리 */

    return IRQ_HANDLED;
}

MSI-X (Message Signaled Interrupts Extended)

현대 GPU 는 MSI-X 를 사용하여 여러 개의 인터럽트 벡터를 할당받습니다. 각 엔진 (GFX, Compute, SDMA, Display) 이 독립적인 IRQ 라인을 가지므로, 한 엔진의 인터럽트 처리가 다른 엔진을 블로킹하지 않습니다.

/* drivers/gpu/drm/amd/amdgpu/amdgpu_irq.c — MSI-X 초기화 */
int
amdgpu_irq_init(struct amdgpu_device *adev)
{
    int ret;

    /* 1. MSI-X 지원 여부 확인 */
    if (pci_enable_msix_range(adev->pdev, NULL, 1, 32) < 0) {
        dev_warn(adev->dev, "MSI-X failed, fallback to INTx\n");
        goto use_intx;
    }

    /* 2. 각 IRQ 벡터에 핸들러 등록 */
    ret = request_threaded_irq(adev->irq.irq, amdgpu_irq_handler,
                               amdgpu_irq_thread, IRQF_ONESHOT,
                               "amdgpu", adev);
    if (ret)
        goto err_disable_msix;

    return 0;

err_disable_msix:
    pci_disable_msix(adev->pdev);
use_intx:
    /* 레거시 INTx 모드 fallback */
    return -EINVAL;
}

VBlank 인터럽트와 페이지(Page) 플립

VBlank(Vertical Blanking Interval) 는 디스플레이의 수직 귀선 소거 기간으로, 이 시점에 프레임버퍼를 교체해야 화면이 찢어지지 않습니다 (Tearing-free).

/* drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c — VBlank IRQ */
static void
dm_dce_crtc_high_irq(struct amdgpu_crtc *acrtc)
{
    struct drm_crtc *crtc = &acrtc->base;
    struct drm_device *dev = crtc->dev;

    /* VBlank 이벤트 발생 — DRM 코어에 알림 */
    drm_crtc_handle_vblank(crtc);

    /* 대기 중인 페이지 플립 완료 처리 */
    amdgpu_dm_complete_flip(crtc);
}

GPU 전원 관리 (Power Management)

현대 GPU 는 높은 성능과 전력 효율을 동시에 달성하기 위해 동적 전원 관리 (Dynamic Power Management, DPM) 를 사용합니다. 리눅스 커널 GPU 드라이버는 runtime PM, 클럭 게이팅 (Clock Gating), 전원 게이팅 (Power Gating), DVFS(Dynamic Voltage and Frequency Scaling) 등을 구현합니다.

전원 관리 계층

Runtime PM — 자동 유휴 진입

Runtime PM 은 디바이스가 유휴 상태(Idle State)일 때 자동으로 전원을 차단하고, 접근 시 복구하는 메커니즘입니다. 사용자 공간은 /sys/bus/pci/devices/<BDF>/power/control 에서 제어할 수 있습니다.

/* drivers/gpu/drm/amd/pm/amdgpu_pm.c — Runtime PM 콜백 */
static int
amdgpu_runtime_suspend(struct device *dev)
{
    struct drm_device *drm_dev = dev_get_drvdata(dev);
    struct amdgpu_device *adev = drm_to_adev(drm_dev);

    /* 1. 모든 엔진이 유휴인지 확인 */
    if (!amdgpu_device_is_idle(adev))
        return -EBUSY;

    /* 2. 디스플레이가 모두 꺼졌는지 확인 (노트북 D3cold 진입 조건) */
    if (amdgpu_device_has_dc_support(adev) &&
        amdgpu_dm_has_display_in_use(adev))
        return -EBUSY;

    /* 3. VRAM 콘텐츠 백업 (필요시) */
    amdgpu_device_evict_resources(adev);

    /* 4. GPU 전원 차단 */
    amdgpu_device_ip_suspend(adev);
    amdgpu_device_fini_hw(adev);

    pci_save_state(adev->pdev);
    return 0;
}

static int
amdgpu_runtime_resume(struct device *dev)
{
    struct drm_device *drm_dev = dev_get_drvdata(dev);
    struct amdgpu_device *adev = drm_to_adev(drm_dev);

    /* 1. PCI 상태 복구 */
    pci_restore_state(adev->pdev);

    /* 2. GPU 전원 온 및 IP 블록 재초기화 */
    amdgpu_device_init_hw(adev);
    amdgpu_device_ip_resume(adev);

    /* 3. VRAM 콘텐츠 복구 (필요시) */
    amdgpu_device_recover_vram(adev);

    return 0;
}

클럭 게이팅 & 전원 게이팅

클럭 게이팅 은 사용하지 않는 블록의 클럭을 차단하여 동적 전력 소비를 줄이고, 전원 게이팅 은 블록 자체의 전원을 차단하여 누설 전력을 제거합니다.

/* drivers/gpu/drm/amd/pm/amdgpu_pm.c — 클럭/전원 게이팅 제어 */
static void
amdgpu_update_clock_gating(struct amdgpu_device *adev, bool enable)
{
    u32 mask = AMD_CG_SUPPORT_GFX_MGCG |      /* GFX Medium Grain Clock Gating */
               AMD_CG_SUPPORT_GFX_CGCG |      /* GFX Coarse Grain Clock Gating */
               AMD_CG_SUPPORT_SDMA_MGCG |     /* SDMA Clock Gating */
               AMD_CG_SUPPORT_UVD_MGCG;       /* UVD Clock Gating */

    if (enable)
        amdgpu_device_ip_set_clockgating_state(adev, AMD_CG_STATE_GATE);
    else
        amdgpu_device_ip_set_clockgating_state(adev, AMD_CG_STATE_UNGATE);
}

static void
amdgpu_update_power_gating(struct amdgpu_device *adev, bool enable)
{
    if (enable) {
        /* GFX 블록 전원 차단 */
        amdgpu_device_ip_set_powergating_state(adev, AMD_PG_STATE_GATE);
    } else {
        /* GFX 블록 전원 온 */
        amdgpu_device_ip_set_powergating_state(adev, AMD_PG_STATE_UNGATE);
    }
}

DVFS (Dynamic Voltage and Frequency Scaling)

PPTable(PowerPlay Table) 는 GPU 의 전압 - 주파수 곡선을 정의하며, 드라이버는 워크로드에 따라 최적의 P-State 를 선택합니다.

열 관리 (Thermal Management)

GPU 는 열 스로틀링 (Thermal Throttling) 으로 온도를 제한하며, 임계치를 초과하면 강제 셧다운됩니다.

/* drivers/gpu/drm/amd/pm/amdgpu_thermal.c — 열 관리 */
struct amdgpu_thermal_controller {
    int min_temp;         /* 팬 최소 동작 온도 (°C × 1000) */
    int max_temp;         /* 팬 최대 동작 온도 */
    int shutdown_temp;    /* 강제 셧다운 임계치 (보통 110-120°C) */
    int throttle_temp;    /* 스로틀링 시작 온도 (보통 85-95°C) */
    int current_temp;     /* 현재 온도 (센서 읽기) */
};

static void
amdgpu_thermal_update(struct amdgpu_device *adev)
{
    int temp = amdgpu_thermal_get_temperature(adev);

    if (temp >= adev->thermal.shutdown_temp) {
        dev_crit(adev->dev, "GPU temperature (%d°C) exceeds shutdown limit!\n", temp / 1000);
        amdgpu_device_shutdown(adev);
    } else if (temp >= adev->thermal.throttle_temp) {
        dev_warn(adev->dev, "GPU thermal throttling activated (%d°C)\n", temp / 1000);
        amdgpu_dpm_force_performance_level(adev, AMD_DPM_FORCED_LEVEL_LOW);
    }
}

GPU 리셋 및 복구 (Reset & Recovery)

GPU 는 복잡한 병렬 처리 장치이므로 hangs(정지), timeouts(타임아웃), errors(오류) 가 빈번하게 발생합니다. 리눅스 커널은 이러한 상황에서 GPU 리셋 을 통해 시스템을 복구하며, 가능한 한 사용자 공간의 작업을 계속 이어나갈 수 있도록 합니다.

리셋 트리거 (Reset Triggers)

GPU 리셋 플로우

/* drivers/gpu/drm/amd/amdgpu/amdgpu_device.c — GPU 리셋 */
bool
amdgpu_device_reset_sriov(struct amdgpu_device *adev, bool from_full_gpu)
{
    int ret;

    /* 1. 모든 IP 블록 프리즌 (작업 중단) */
    ret = amdgpu_device_ip_freeze(adev);
    if (ret)
        return false;

    /* 2. RAS 에러 클리어 (ECC 등) */
    amdgpu_ras_reset_all_error_count(adev);

    /* 3. BACO 리셋 (Board Active Chip Off) — 전력 완전 차단 */
    ret = amdgpu_device_baco_reset(adev);
    if (ret)
        goto unfreeze;

    /* 4. 모든 IP 블록 재초기화 */
    ret = amdgpu_device_ip_resume(adev);
    if (ret)
        goto error;

    /* 5. VRAM 테스트 — 메모리 손상 여부 확인 */
    ret = amdgpu_vram_test(adev);
    if (ret) {
        dev_err(adev->dev, "VRAM test failed after reset!\n");
        goto error;
    }

    return true;

error:
    amdgpu_device_fini_hw(adev);
unfreeze:
    amdgpu_device_ip_unfreeze(adev);
    return false;
}

리셋의 영향

DRM Accel 서브시스템 (비그래픽 가속기)

전통적으로 DRM(Direct Rendering Manager)은 그래픽 출력을 담당하는 GPU만을 관리했으나, 현대 SoC와 x86 플랫폼에는 그래픽 파이프라인 없이 연산만 수행하는 가속기(Accelerator)가 늘어나면서 커널 6.2에서 drivers/accel/ 트리와 /dev/accel/accel* 노드가 도입되었습니다. DRM의 버퍼·fence·스케줄러 인프라를 재사용하되, 디스플레이와 관련된 KMS 경로를 완전히 제거한 경량 경로입니다.

커널 트리에 상주하는 주요 Accel 드라이버

각 Accel 드라이버의 상세 아키텍처, 컴파일러 스택, DMA-BUF 연계는 NPU 문서에서 다룹니다. 최근 몇 년간 Accel 드라이버가 꾸준히 추가되면서, NPU 하드웨어 다변화가 본격화되고 있습니다. 다만 개별 드라이버의 정확한 공개 시점과 머지 여부는 메인라인 릴리스 노트를 다시 확인하는 편이 안전합니다.

Accel UAPI와 일반 DRM UAPI의 공통·차이점

Rust GPU 드라이버 생태계

2025년은 Rust 언어가 리눅스 커널 GPU 서브시스템에 본격 도입된 분기점입니다. 메모리 안전 언어로 GPU 드라이버를 작성하려는 흐름은 Apple Silicon에서 시작되어, NVIDIA GSP 드라이버(Nova)가 메인라인에 합류하면서 가속됐습니다. 기존 C 기반 DRM 인프라는 그대로 유지하면서, 새 드라이버가 DRM 바인딩을 Rust로 감싸는 방식으로 확장됩니다.

Nova — NVIDIA GSP 기반 Rust DRM 드라이버 (커널 6.15+)

Nova는 NVIDIA GeForce RTX 20(Turing) 이후 세대의 GPU System Processor(GSP) 기반 GPU를 위한 새 드라이버로, Red Hat의 Danilo Krummrich가 주도하여 2025년 5월 커널 6.15에 drivers/gpu/drm/nova/가 머지됐습니다. 기존 Nouveau를 대체하는 후속 드라이버를 목표로 하며, 현재는 초기 코어 컴포넌트와 프로젝트 문서만 머지된 실험 단계입니다. 2025년 하반기에는 NVIDIA 소속 엔지니어가 공동 메인테이너로 합류했습니다.

Asahi AGX — Apple Silicon GPU 드라이버

Apple M1/M2/M3/M4 시리즈의 내장 GPU인 AGX는 Asahi Linux 프로젝트에서 Rust로 작성한 드라이버로 리눅스에서 구동됩니다. AGX 드라이버는 DRM 서브시스템용 Rust 바인딩을 실제 production-level로 처음 도입한 사례로, Mesa의 Honeykrisp(Vulkan) / Gallium AGX(OpenGL 4.6, ES 3.2) 드라이버와 짝을 이룹니다. 현재 업스트림 머지 목표로 AsahiLinux/linux의 gpu/rust-wip 브랜치에서 재작성이 진행 중입니다.

Rust DRM 바인딩의 공통 기반

두 드라이버는 공통으로 다음 Rust 추상화에 의존합니다:

• kernel::drm::device — drm_device 래퍼와 driver registration
• kernel::drm::file — 파일 ops, ioctl dispatch
• kernel::drm::gem — GEM Object 트레이트와 수명주기 관리
• kernel::drm::sched — drm_sched Rust 래퍼 (진행 중)
• kernel::dma_fence — dma_fence 래퍼로 동기화 프리미티브를 안전하게 다룹니다

이들 크레이트는 기존 C API를 그대로 호출하므로 ABI 변경 없이 공존하며, unsafe 블록은 FFI 경계에만 남겨 안전성을 확보합니다.

drm_panic — 커널 패닉(Kernel Panic) 화면 인프라

드라이버가 Wayland·compositor 없이 DRM 프레임버퍼만 보유한 상태에서도 커널 패닉(Kernel Panic) 시 사용자에게 읽을 수 있는 메시지를 남기는 구조가 2024년 커널 6.10에서 추가되었습니다. fbcon(Frame Buffer Console)이 없거나 VT가 꺼진 환경에서도 화면에 패닉 내용을 그려주며, Fedora와 Arch 계열처럼 이를 적극 도입한 배포판이 있습니다. 다만 2026년 4월 기준으로 배포판별 기본 활성 범위와 사용자 노출 방식은 릴리스별로 다를 수 있으므로 해당 배포판 문서를 함께 확인하는 편이 안전합니다.

동작 원리

패닉 시 드라이버가 등록한 drm_panic 콜백(Callback)이 호출되어, fence·mutex 없이 MMIO만으로 프레임버퍼를 직접 갱신합니다. 따라서 패닉 루틴은 일반 드라이버 경로와 완전히 분리된 lock-free·interrupt-safe 구현이어야 합니다.

/* include/drm/drm_panic.h */
struct drm_panic_scanout {
    void        *vaddr;      /* 직접 접근 가능한 프레임버퍼 포인터 */
    unsigned int pitch;      /* 라인 당 바이트 */
    unsigned int width, height;
    u32          format;     /* DRM_FORMAT_* */
};

struct drm_plane_helper_funcs {
    ...
    int (*get_scanout_buffer)(struct drm_plane *, struct drm_panic_scanout *);
    void (*panic_flush)(struct drm_plane *);
};

지원 드라이버 현황 (2026년 기준)

GPU 가상화 (Virtualization)

가상 머신(VM)과 컨테이너에서 GPU 를 활용하려는 수요가 커지면서, 리눅스는 여러 계층의 GPU 가상화 방식을 지원합니다. 각 방식은 성능 · 격리(Isolation) · 공유 밀도의 균형점이 다릅니다. 크게 API 포워딩, DRM native context(vDRM), 하드웨어 분할(SR-IOV), 전체 패스스루(Passthrough)로 나뉩니다.

DRM native context (vDRM)

vDRM(virtual DRM)은 Virgl/Venus 처럼 고수준 그래픽 API 를 매개하는 대신, 리눅스 커널 드라이버의 UAPI(ioctl) 수준에서 매개합니다. 따라서 게스트 안의 GL/Vulkan 애플리케이션은 가상 GPU 를 실제 호스트 GPU 처럼 직접 다루며, 중간 번역 단계가 줄어 CPU 오버헤드와 구현 복잡도가 모두 낮아집니다. QEMU 에서는 -device virtio-gpu-gl,drm_native_context=on 옵션으로 활성화합니다.

vDRM 컨텍스트는 GPU 드라이버마다 호스트·게스트 양쪽 구현이 필요합니다. 2025년 기준 업스트림 현황은 다음과 같습니다:

SR-IOV 와 하드웨어 분할

SR-IOV(Single Root I/O Virtualization)는 PCIe 표준 기능으로, 하나의 물리 GPU(PF, Physical Function)를 여러 개의 VF(Virtual Function)로 분할하여 각 VM 에 거의 네이티브에 가까운 성능으로 할당합니다.

• AMD MxGPU — GIM(GPU-IOV Module) 커널 모듈(Kernel Module)로 VF 를 관리하며, 데이터센터 GPU 에서 다중 VM 공유를 지원합니다.
• Intel Xe SR-IOV — 커널 6.18 에서 지원 플랫폼의 PF 모드가 기본 활성화되었고, 7.0 에서 VF 마이그레이션(VM 라이브 마이그레이션 대응)과 PF MERT 가 추가되었습니다. Battlemage(Arc B 시리즈)에서도 SR-IOV 가 확장되고 있습니다.

2025-2026 DRM 동향과 커널 버전 매트릭스

2025년부터 2026년 상반기까지 GPU·가속기 서브시스템에 머지된 주요 기능을 커널 버전별로 요약합니다. 배포판 선택·드라이버 포팅 계획에 참고할 수 있습니다.

관련 연혁: GPU / DRM 변경 이력

3대 하이라이트

1. Rust의 본격 도입 — Nova(NVIDIA)·Asahi AGX(Apple)·Tyr(Arm) 등 Rust 기반 DRM 드라이버가 잇따라 제안되고, kernel::drm 바인딩이 안정화 경로에 들어섰습니다.
2. 가속기 생태계 확장 — AMDXDNA(Ryzen AI)·Rockchip Rocket(RK3588)에 이어, 2026년에도 최소 2종의 새 NPU 드라이버가 예정되어 Accel 서브시스템이 GPU 못지 않은 규모로 성장 중입니다.
3. 색 파이프라인·동기화 현대화 — KMS Color Pipeline API(HDR), linux_drm_syncobj_v1(Wayland explicit sync), DMEM cgroup(VRAM 제한), Fair DRM Scheduler 등으로 게임·HDR·컨테이너 워크로드에서의 체감 품질이 크게 개선됐습니다.

커널 버전별 주요 변경사항 (2025~2026)

참고자료

관련 문서

이 주제와 관련된 다른 문서를 더 깊이 이해하고 싶다면 다음을 참고하세요.

• DRM 코어 및 디스플레이 (KMS) — DRM 코어, KMS, atomic modesetting, 디스플레이 프로토콜
• GPU 메모리 관리 및 스케줄러 — GEM/TTM, DMA-BUF, GPU 스케줄러, GPUVM, 전원 관리
• GPU 컴퓨팅 (GPGPU) — CUDA, OpenCL, Vulkan Compute, ROCm/HIP, Intel oneAPI
• ROCm / HIP — AMD GPU 컴퓨트 플랫폼, KFD 드라이버, RDNA/CDNA 아키텍처
• NPU (Neural Processing Unit) — AI 가속 디바이스
• 디바이스 드라이버 — 디바이스 드라이버 모델, DMA, IRQ
• PCI / PCIe — PCI/PCIe 버스(Bus) 아키텍처
• 인터럽트(Interrupt) 처리 — IRQ 핸들링
• DMA — DMA 매핑(Mapping)과 전송
• 전원 관리 — 디바이스 전원 관리