DMA (Direct Memory Access)

Linux DMA 서브시스템을 디바이스-메모리 데이터 경로의 성능과 안전성 관점에서 심층 분석합니다. Coherent/Streaming/SG/Pool 매핑 API의 수명주기, IOMMU(VT-d/AMD-Vi/SMMU)와 SWIOTLB fallback 경로, CMA와 장치 제약 메모리 할당, DMA-BUF 기반 서브시스템 간 버퍼 공유, P2P DMA와 NUMA 배치, 캐시 일관성 및 배리어 규칙, 데이터 손상 방지를 위한 동기화 절차, debugfs/tracepoint로 병목을 추적하는 방법까지 실전 드라이버에서 자주 마주치는 이슈를 폭넓게 다룹니다.

DMA 개요

DMA(Direct Memory Access)는 CPU 개입 없이 디바이스가 시스템 메모리에 직접 읽기/쓰기를 수행하는 메커니즘입니다. CPU는 전송을 설정한 뒤 다른 작업을 수행할 수 있어 시스템 전체 처리량이 크게 향상됩니다.

PIO vs DMA 비교

DMA 발전사

커널 소스 트리 구조

DMA 주소 공간과 매핑

DMA 프로그래밍에서 가장 혼란스러운 부분은 여러 주소 공간이 동시에 존재한다는 점입니다.

주소 유형

DMA 존(Zone)과 주소 마스크

/* DMA 마스크 설정 — 디바이스의 주소 지정 능력을 커널에 알림 */
int ret;

/* 64비트 DMA 가능한 디바이스 */
ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64));
if (ret) {
    /* 64비트 실패 시 32비트로 폴백 */
    ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
    if (ret) {
        dev_err(dev, "No suitable DMA available\\n");
        return ret;
    }
}

/* dma_set_mask_and_coherent()는 다음 두 호출의 조합: */
/* dma_set_mask(dev, mask)      — streaming 매핑용 마스크 */
/* dma_set_coherent_mask(dev, mask) — coherent 할당용 마스크 */

DMA 매핑 백엔드 (dma_map_ops)

dma_map_single() 등 DMA 매핑 API는 내부적으로 struct dma_map_ops 백엔드를 통해 실제 매핑을 수행합니다. 시스템 구성에 따라 적절한 백엔드가 자동 선택됩니다.

Device Tree의 dma-ranges

ARM/RISC-V 등 플랫폼에서 버스 주소와 물리 주소가 다를 수 있으며, dma-ranges 속성으로 변환을 정의합니다:

/* DTS 예시: 버스 주소 0x0이 물리 주소 0x80000000에 매핑 */
soc {
    #address-cells = <1>;
    #size-cells = <1>;
    dma-ranges = <0x0 0x80000000 0x40000000>;
    /* child_bus_addr  parent_phys_addr  length */
};

DMA 매핑 API 상세

Linux 커널은 DMA 매핑을 위해 5가지 주요 API를 제공합니다. 모든 API는 <linux/dma-mapping.h>에 선언되어 있습니다.

API 유형 비교

Coherent (Consistent) DMA

CPU와 디바이스가 동시에 접근하는 공유 메모리에 사용합니다. 하드웨어가 캐시 일관성을 보장합니다.

#include <linux/dma-mapping.h>

dma_addr_t dma_handle;
void *cpu_addr;
size_t size = 4096;

/* 할당: CPU 가상주소 + DMA 버스주소를 동시에 얻음 */
cpu_addr = dma_alloc_coherent(dev, size, &dma_handle, GFP_KERNEL);
if (!cpu_addr)
    return -ENOMEM;

/* cpu_addr로 CPU 접근, dma_handle로 디바이스에 주소 전달 */
desc->buf_addr = cpu_to_le64(dma_handle);

/* 해제 */
dma_free_coherent(dev, size, cpu_addr, dma_handle);

Streaming DMA — 단일 버퍼

한 번의 I/O 전송 동안만 유효한 매핑입니다. 전송 후 반드시 unmap해야 합니다.

dma_addr_t dma_handle;
void *buf = kmalloc(4096, GFP_KERNEL);

/* 매핑: 방향(Direction)은 데이터 흐름을 나타냄 */
dma_handle = dma_map_single(dev, buf, 4096, DMA_TO_DEVICE);
if (dma_mapping_error(dev, dma_handle)) {
    dev_err(dev, "DMA mapping failed\\n");
    kfree(buf);
    return -EIO;
}

/* 디바이스에 dma_handle 전달, 전송 시작 */
start_device_transfer(dma_handle, 4096);

/* 전송 완료 후 unmap */
dma_unmap_single(dev, dma_handle, 4096, DMA_TO_DEVICE);

Streaming DMA — Scatter-Gather

물리적으로 비연속인 여러 페이지를 하나의 DMA 전송으로 묶는 기법입니다. NIC의 패킷 fragment, 블록 계층의 BIO segment, Crypto Framework (Crypto API)의 입출력 버퍼, GPU 커맨드 버퍼 등 거의 모든 DMA 드라이버에서 핵심 패턴으로 사용됩니다. 커널은 struct scatterlist와 struct sg_table을 통해 이러한 비연속 메모리 영역을 표현하고, IOMMU가 있는 경우 여러 SG 엔트리를 하나의 연속 IOVA 영역으로 병합하여 DMA 효율을 극대화합니다.

struct scatterlist / struct sg_table

Scatter-gather의 기본 데이터 구조는 struct scatterlist와 이를 감싸는 struct sg_table입니다.

struct scatterlist {
    unsigned long   page_link;    /* 페이지 포인터 + bit0:chain + bit1:last */
    unsigned int    offset;       /* 페이지 내 시작 오프셋 */
    unsigned int    length;       /* 데이터 길이 (바이트) */
    dma_addr_t      dma_address;  /* DMA 매핑 후 디바이스 주소 */
    unsigned int    dma_length;   /* DMA 매핑 후 길이 (병합 시 변경) */
};

struct sg_table {
    struct scatterlist *sgl;      /* 첫 번째 scatterlist 포인터 */
    unsigned int    nents;        /* DMA 매핑 후 엔트리 수 */
    unsigned int    orig_nents;   /* 원본(매핑 전) 엔트리 수 */
};

SG 체이닝 메커니즘

단일 scatterlist 배열의 크기는 스택이나 슬랩 할당의 제약을 받습니다. 대용량 I/O(수백~수천 세그먼트)를 위해 커널은 여러 scatterlist 배열을 연결하는 체이닝 메커니즘을 제공합니다. 배열의 마지막 엔트리에서 page_link의 bit0(chain)을 설정하고, 페이지 포인터 대신 다음 배열의 주소를 저장합니다.

struct scatterlist sg1[4], sg2[4];

/* sg1, sg2 각각 초기화 */
sg_init_table(sg1, 4);
sg_init_table(sg2, 4);

/* sg1[3]을 chain 엔트리로 설정하여 sg2를 연결 */
sg_chain(sg1, 4, sg2);

/* 이제 sg1부터 sg_next()로 sg2까지 연속 순회 가능 */
struct scatterlist *s;
int i;
for_each_sg(sg1, s, 7, i) {
    /* sg1[0..2] → sg2[0..3] 순서로 7개 순회 */
    pr_info("sg[%d]: page=%p offset=%u len=%u\\n",
            i, sg_page(s), s->offset, s->length);
}

SG 테이블 API

Raw scatterlist[] 배열 대신 struct sg_table을 사용하면 할당, 해제, 체이닝을 자동으로 처리합니다.

struct sg_table sgt;
int ret;

/* 방법 1: 빈 SG 테이블 할당 후 수동 설정 */
ret = sg_alloc_table(&sgt, nfrags, GFP_KERNEL);
if (ret)
    return ret;

/* 방법 2: 페이지 배열로부터 직접 SG 테이블 생성 */
ret = sg_alloc_table_from_pages(&sgt, pages, n_pages,
                                offset, size, GFP_KERNEL);

/* 해제 */
sg_free_table(&sgt);

기본 SG 매핑 워크플로

SG 매핑의 기본 흐름은 5단계로 구성됩니다: (1) SG 테이블 초기화 → (2) 각 엔트리에 페이지 설정 → (3) dma_map_sg()로 DMA 매핑 → (4) for_each_sg()로 매핑 결과 순회 → (5) dma_unmap_sg()로 해제.

struct scatterlist sg[MAX_FRAGS];
int nents, mapped_nents;

sg_init_table(sg, nfrags);
for (i = 0; i < nfrags; i++)
    sg_set_page(&sg[i], pages[i], len[i], offset[i]);

/* 매핑: IOMMU가 있으면 여러 SG를 하나의 연속 IOVA로 병합 가능 */
mapped_nents = dma_map_sg(dev, sg, nfrags, DMA_FROM_DEVICE);
if (!mapped_nents) {
    dev_err(dev, "SG DMA mapping failed\\n");
    return -EIO;
}

/* mapped_nents ≤ nfrags (IOMMU 병합 시 줄어듦) */
for_each_sg(sg, s, mapped_nents, i) {
    hw_desc[i].addr = sg_dma_address(s);
    hw_desc[i].len  = sg_dma_len(s);
}

/* 전송 완료 후 */
dma_unmap_sg(dev, sg, nfrags, DMA_FROM_DEVICE);

dma_map_sgtable() (최신 API)

커널 5.8 이후 도입된 dma_map_sgtable()은 sg_table을 직접 받아 nents/orig_nents를 자동 관리하고, 오류 시 음수 errno를 반환하여 기존 API의 불편함을 해소합니다.

struct sg_table sgt;
int ret;

/* 페이지 배열로부터 SG 테이블 생성 */
ret = sg_alloc_table_from_pages(&sgt, pages, n_pages,
                                offset, size, GFP_KERNEL);
if (ret)
    return ret;

/* 최신 API로 DMA 매핑 — 음수 errno 반환 */
ret = dma_map_sgtable(dev, &sgt, DMA_BIDIRECTIONAL, 0);
if (ret) {
    dev_err(dev, "sgtable DMA map failed: %d\\n", ret);
    sg_free_table(&sgt);
    return ret;
}

/* DMA 매핑된 엔트리 순회 (sgt.nents 자동 사용) */
struct scatterlist *s;
int i;
for_each_sgtable_dma_sg(&sgt, s, i) {
    hw_desc[i].addr = sg_dma_address(s);
    hw_desc[i].len  = sg_dma_len(s);
}

/* 전송 완료 후 해제 — nents 인자 불필요 */
dma_unmap_sgtable(dev, &sgt, DMA_BIDIRECTIONAL, 0);
sg_free_table(&sgt);

SG 순회 매크로

SG 엔트리를 순회할 때는 CPU 관점(원본 엔트리)과 DMA 관점(매핑 후 엔트리)을 구분해야 합니다. IOMMU 병합으로 인해 두 관점의 엔트리 수가 다를 수 있습니다.

/* CPU 관점: 원본 페이지에 대해 sync/접근 */
for_each_sgtable_sg(&sgt, s, i) {
    struct page *page = sg_page(s);
    void *vaddr = kmap_local_page(page);
    memset(vaddr + s->offset, 0, s->length);
    kunmap_local(vaddr);
}

/* DMA 관점: HW 디스크립터에 DMA 주소 설정 */
for_each_sgtable_dma_sg(&sgt, s, i) {
    hw_desc[i].addr = sg_dma_address(s);
    hw_desc[i].len  = sg_dma_len(s);
}

IOMMU SG 병합

IOMMU가 활성화된 시스템에서 dma_map_sg()는 물리적으로 비연속인 여러 페이지를 하나의 연속 IOVA(I/O Virtual Address) 영역에 매핑할 수 있습니다. 이를 SG 병합(merging)이라 하며, 디바이스에게는 하나의 큰 연속 버퍼로 보이게 합니다.

병합이 일어나면 dma_map_sg()의 반환값(mapped_nents)이 원본 엔트리 수(nfrags)보다 작아집니다. IOMMU가 없는 시스템에서는 병합이 불가능하므로 mapped_nents == nfrags가 됩니다.

/* 4개의 비연속 페이지를 SG로 매핑 */
mapped = dma_map_sg(dev, sg, 4, DMA_TO_DEVICE);

/* IOMMU 있는 시스템: mapped = 1 (4페이지 → 1개 연속 IOVA) */
/* IOMMU 없는 시스템: mapped = 4 (각 페이지 독립) */

for_each_sg(sg, s, mapped, i) {
    pr_info("DMA seg[%d]: addr=0x%llx len=%u\\n",
            i, sg_dma_address(s), sg_dma_len(s));
}
/* IOMMU: DMA seg[0]: addr=0xf0000 len=16384 */
/* 직접: DMA seg[0..3]: 각각 4096 */

오류 처리 패턴

SG DMA 매핑은 IOVA 공간 고갈, 메모리 부족 등으로 실패할 수 있습니다. Legacy API와 Modern API의 오류 반환 방식이 다르므로 주의해야 합니다.

struct sg_table sgt;
int ret;

/* 1. SG 테이블 할당 */
ret = sg_alloc_table_from_pages(&sgt, pages, n_pages,
                                0, total_size, GFP_KERNEL);
if (ret)
    return ret;

/* 2. DMA 매핑 (최신 API) */
ret = dma_map_sgtable(dev, &sgt, DMA_FROM_DEVICE, 0);
if (ret)
    goto err_free_sgt;

/* 3. HW 디스크립터 설정 및 전송 */
setup_hw_descriptors(&sgt);
ret = start_dma_transfer(dev);
if (ret)
    goto err_unmap;

/* 4. 전송 완료 대기 후 정리 */
wait_for_completion(&done);

err_unmap:
    dma_unmap_sgtable(dev, &sgt, DMA_FROM_DEVICE, 0);
err_free_sgt:
    sg_free_table(&sgt);
    return ret;

성능 고려사항

SG DMA의 성능은 세그먼트 수, HW 제한, IOMMU 설정에 크게 영향받습니다.

DMA Pool

고정 크기 소형 coherent 버퍼를 효율적으로 반복 할당/해제할 때 사용합니다. 내부적으로 dma_alloc_coherent()에서 큰 블록을 할당 후 분할합니다.

struct dma_pool *pool;
dma_addr_t dma_handle;
void *buf;

/* 풀 생성: 256바이트 블록, 16바이트 정렬, 4KB 경계 내 */
pool = dma_pool_create("my_desc", dev, 256, 16, 4096);

/* 풀에서 할당 */
buf = dma_pool_alloc(pool, GFP_KERNEL, &dma_handle);

/* 반환 */
dma_pool_free(pool, buf, dma_handle);

/* 풀 해제 */
dma_pool_destroy(pool);

Non-coherent DMA

대용량 버퍼에서 캐시를 명시적으로 제어하여 성능을 최적화할 때 사용합니다:

/* 비캐시-일관 할당: 아키텍처에 따라 uncached 또는 write-combine */
cpu_addr = dma_alloc_noncoherent(dev, size, &dma_handle,
                                   DMA_FROM_DEVICE, GFP_KERNEL);

/* CPU가 읽기 전에 캐시 무효화 */
dma_sync_single_for_cpu(dev, dma_handle, size, DMA_FROM_DEVICE);

/* 디바이스에 다시 넘기기 전에 캐시 플러시 */
dma_sync_single_for_device(dev, dma_handle, size, DMA_FROM_DEVICE);

dma_free_noncoherent(dev, size, cpu_addr, dma_handle, DMA_FROM_DEVICE);

DMA 속성과 특수 매핑

DMA 매핑 API는 attrs 파라미터를 통해 매핑 동작을 세밀하게 제어할 수 있습니다. <linux/dma-mapping.h>에 정의된 DMA_ATTR_* 플래그를 비트 OR로 결합하여 전달합니다.

DMA_ATTR_* 플래그 종합

Write-Combine 매핑

Write-Combine(WC)은 CPU 캐시를 사용하지 않으면서도 쓰기 버퍼를 결합하여 순차 쓰기 성능을 극대화하는 메모리 타입입니다. 프레임버퍼, GPU 커맨드 버퍼, MMIO 레지스터 스트리밍 등에 적합합니다.

/* Write-Combine 할당 — 전용 API */
void *wc_buf;
dma_addr_t dma_handle;

wc_buf = dma_alloc_wc(dev, size, &dma_handle, GFP_KERNEL);
if (!wc_buf)
    return -ENOMEM;

/* 순차 쓰기에 최적 — GPU 커맨드 스트리밍 */
memcpy_toio(wc_buf, cmd_data, cmd_len);
wmb();  /* WC 버퍼 flush 보장 */

dma_free_wc(dev, size, wc_buf, dma_handle);

/* 또는 속성 기반 할당 */
cpu_addr = dma_alloc_attrs(dev, size, &dma_handle,
                           GFP_KERNEL, DMA_ATTR_WRITE_COMBINE);

NO_KERNEL_MAPPING — 커널 주소 공간 절약

비디오 프레임이나 카메라 캡처 버퍼처럼 CPU가 직접 접근할 필요 없는 대용량 DMA 버퍼에서는 커널 가상 주소 매핑을 생략하여 vmalloc 공간을 절약할 수 있습니다.

/* 커널 VA 매핑 없이 DMA 전용 버퍼 할당 */
struct page *page;
dma_addr_t dma_handle;

page = dma_alloc_pages(dev, size, &dma_handle,
                       DMA_FROM_DEVICE,
                       GFP_KERNEL | __GFP_ZERO);
if (!page)
    return -ENOMEM;

/* CPU가 잠시 접근해야 할 때만 kmap */
void *vaddr = kmap_local_page(page);
process_header(vaddr, header_len);
kunmap_local(vaddr);

/* 유저스페이스에 mmap으로 노출 가능 */
dma_mmap_pages(dev, vma, size, page);

dma_free_pages(dev, size, page, dma_handle, DMA_FROM_DEVICE);

SKIP_CPU_SYNC — 수동 캐시 제어

대량의 SG 엔트리를 매핑할 때 기본 sync 동작을 건너뛰고, 실제 데이터 접근 시점에만 선택적으로 sync하여 오버헤드를 줄입니다.

/* map 시 sync 건너뜀 — 나중에 직접 sync */
dma_handle = dma_map_single_attrs(dev, buf, len,
                                   DMA_FROM_DEVICE,
                                   DMA_ATTR_SKIP_CPU_SYNC);

/* 디바이스 전송 완료 후, 필요한 부분만 sync */
dma_sync_single_range_for_cpu(dev, dma_handle,
                              offset, partial_len,
                              DMA_FROM_DEVICE);

/* offset ~ offset+partial_len 구간만 CPU가 읽음 */
process_data(buf + offset, partial_len);

Managed (Devres) DMA API

디바이스 해제 시 자동으로 정리되는 관리형 DMA API입니다. probe()에서 할당하고 별도 remove() 정리 코드가 필요 없어 리소스 누수를 방지합니다.

static int my_probe(struct pci_dev *pdev, ...)
{
    struct device *dev = &pdev->dev;

    /* Managed 할당 — remove()에서 free 불필요 */
    priv->ring = dmam_alloc_coherent(dev, RING_SIZE,
                                      &priv->ring_dma,
                                      GFP_KERNEL);
    if (!priv->ring)
        return -ENOMEM;

    priv->pool = dmam_pool_create("my_pool", dev,
                                   256, 16, 0);
    if (!priv->pool)
        return -ENOMEM;
    /* priv->ring과 priv->pool은 pci_dev 해제 시 자동 정리 */

    return 0;
}

dma_map_resource() — MMIO 주소 매핑

시스템 RAM이 아닌 디바이스 MMIO 영역(BAR)을 다른 디바이스가 DMA로 접근할 수 있도록 매핑합니다. P2P DMA의 기초입니다.

/* NIC가 GPU BAR 영역에 직접 DMA하기 위한 매핑 */
dma_addr_t dma_handle;
phys_addr_t gpu_bar_phys = pci_resource_start(gpu_pdev, 0);
size_t gpu_bar_len = pci_resource_len(gpu_pdev, 0);

dma_handle = dma_map_resource(nic_dev, gpu_bar_phys,
                              gpu_bar_len, DMA_BIDIRECTIONAL, 0);
if (dma_mapping_error(nic_dev, dma_handle))
    return -EIO;

/* NIC 디스크립터에 gpu_bar의 DMA 주소 설정 → P2P 전송 */

dma_unmap_resource(nic_dev, dma_handle, gpu_bar_len,
                   DMA_BIDIRECTIONAL, 0);

DMA 방향과 캐시 일관성

DMA 방향 상수

아키텍처별 캐시 일관성 모델

Sync API 상세

Streaming 매핑을 unmap하지 않고 CPU ↔ 디바이스 간 소유권을 전환할 때 사용합니다:

/* 수신 링 버퍼 — 반복 사용 패턴 */
dma_addr = dma_map_single(dev, buf, len, DMA_FROM_DEVICE);

while (running) {
    /* 디바이스가 데이터 기록 완료 (인터럽트 등) */
    dma_sync_single_for_cpu(dev, dma_addr, len, DMA_FROM_DEVICE);

    /* CPU가 buf의 데이터를 읽음 */
    process_data(buf, len);

    /* 다시 디바이스에 소유권 넘김 */
    dma_sync_single_for_device(dev, dma_addr, len, DMA_FROM_DEVICE);

    /* 디바이스에 버퍼 재사용 통보 */
    notify_device_reuse(dma_addr);
}

dma_unmap_single(dev, dma_addr, len, DMA_FROM_DEVICE);

DMA 메모리 배리어와 순서 보장

DMA 프로그래밍에서 메모리 배리어는 CPU 쓰기가 디바이스에 올바른 순서로 보이게 하고, 디바이스 쓰기가 CPU에 올바르게 보이게 하는 핵심 메커니즘입니다. 배리어 누락은 극히 재현 어려운 데이터 손상 버그를 유발합니다.

DMA 관련 배리어 유형

디스크립터 링 배리어 패턴

NIC, NVMe 등 디스크립터 기반 DMA에서 가장 흔한 배리어 사용 패턴입니다:

/* ── 송신 경로: CPU가 디스크립터 작성 → 디바이스가 읽기 ── */

/* 1. 디스크립터 데이터 필드 작성 */
desc->buf_addr = cpu_to_le64(dma_handle);
desc->buf_len  = cpu_to_le32(len);
desc->flags    = cpu_to_le32(TX_FLAGS);

/* 2. DMA 쓰기 배리어: 위의 쓰기가 아래보다 먼저 보이게 */
dma_wmb();

/* 3. ownership 비트 설정 (디바이스에 소유권 이전) */
desc->status = cpu_to_le32(DESC_OWN);

/* 4. MMIO doorbell: 디바이스에 새 디스크립터 통보 */
wmb();  /* DMA 메모리 쓰기가 MMIO 전에 완료되도록 */
writel(tail_idx, priv->doorbell_reg);

/* ── 수신 경로: 디바이스가 디스크립터 작성 → CPU가 읽기 ── */

/* 1. ownership 비트 확인 (디바이스가 완료했는지) */
if (!(le32_to_cpu(desc->status) & DESC_DONE))
    return;  /* 아직 미완료 */

/* 2. DMA 읽기 배리어: status 읽기 후 데이터 필드 읽기 순서 보장 */
dma_rmb();

/* 3. 디스크립터 데이터 필드 읽기 */
pkt_len = le32_to_cpu(desc->pkt_len);
pkt_addr = le64_to_cpu(desc->buf_addr);

readl/writel vs ioread32/iowrite32

Linux MMIO 접근 함수들은 내장된 배리어 수준이 다릅니다:

/* 성능 최적화: 여러 레지스터를 연속 쓸 때 relaxed 사용 */
writel_relaxed(val1, reg + 0x00);
writel_relaxed(val2, reg + 0x04);
writel_relaxed(val3, reg + 0x08);
writel(val4, reg + 0x0C);  /* 마지막만 정규 writel → 모든 쓰기 완료 보장 */

배리어 관련 흔한 실수

IOMMU 심화

IOMMU(Input/Output Memory Management Unit)는 디바이스의 DMA 요청에 대해 가상→물리 주소 변환을 수행하고, 디바이스 간 메모리 접근을 격리합니다.

주요 IOMMU 구현

IOMMU 동작 모드

IOMMU 그룹과 격리

IOMMU 그룹은 하드웨어적으로 격리 가능한 최소 단위입니다. 같은 그룹 내 디바이스는 서로의 DMA를 볼 수 있으므로 VFIO passthrough 시 그룹 단위로 할당해야 합니다.

/* IOMMU 그룹 조회 */
$ ls /sys/kernel/iommu_groups/*/devices/
/* 출력 예시 */
/sys/kernel/iommu_groups/1/devices/0000:03:00.0
/sys/kernel/iommu_groups/1/devices/0000:03:00.1
/sys/kernel/iommu_groups/2/devices/0000:01:00.0

/* ACS(Access Control Services) 확인 — 격리 수준 판단 */
$ lspci -vvs 03:00.0 | grep -i acs

ATS, PRI, PASID

/* SVA(Shared Virtual Addressing) — 유저 가상 주소를 디바이스가 직접 사용 */
#include <linux/iommu.h>

struct iommu_sva *sva;

/* 디바이스를 현재 프로세스 주소 공간에 바인딩 */
sva = iommu_sva_bind_device(dev, current->mm);
pasid = iommu_sva_get_pasid(sva);

/* 디바이스에 PASID와 유저 VA 전달 → 디바이스가 직접 접근 */
hw_submit_work(pasid, user_va, len);

/* 언바인드 */
iommu_sva_unbind_device(sva);

IOMMU 도메인 API

struct iommu_domain은 IOMMU 주소 공간의 단위입니다. 같은 도메인에 연결된 디바이스들은 동일한 IOVA→PA 매핑을 공유합니다. DMA API는 내부적으로 도메인을 관리하지만, VFIO 등에서는 직접 도메인 API를 사용합니다.

/* VFIO 스타일: 유저스페이스 관리 도메인 */
struct iommu_domain *domain;

/* 1. Unmanaged 도메인 생성 */
domain = iommu_domain_alloc(dev->bus);
if (!domain)
    return -ENOMEM;

/* 2. 디바이스를 도메인에 연결 */
ret = iommu_attach_device(domain, dev);
if (ret)
    goto free_domain;

/* 3. IOVA → PA 매핑 추가 (VFIO가 유저 메모리를 매핑) */
ret = iommu_map(domain, iova, phys_addr, size,
               IOMMU_READ | IOMMU_WRITE, GFP_KERNEL);

/* 4. 매핑 해제 */
iommu_unmap(domain, iova, size);

/* 5. 정리 */
iommu_detach_device(domain, dev);
free_domain:
iommu_domain_free(domain);

IOMMU 페이지 테이블 포맷

주요 IOMMU는 각각 고유한 페이지 테이블 구조를 사용하지만, 기본 원리(다단계 테이블, 4KB/2MB/1GB 페이지)는 CPU MMU와 유사합니다.

IOTLB 관리와 Flush 전략

IOMMU도 CPU TLB처럼 변환 캐시(IOTLB)를 사용합니다. 매핑 해제 시 IOTLB를 무효화해야 하며, 이 전략이 DMA 성능에 큰 영향을 미칩니다.

/* IOTLB flush가 DMA 성능에 미치는 영향 확인 */
/* perf로 IOTLB miss 추적 (Intel VT-d) */
$ perf stat -e dTLB-load-misses,dTLB-store-misses \
    -e iommu/iommu_tlb_inv_tlb/ dd if=/dev/nvme0n1 of=/dev/null bs=4k count=10000

/* lazy vs strict 전환 (재부팅 불필요, 도메인 단위) */
$ echo 1 > /sys/kernel/debug/iommu/intel/dmar0/strict
$ echo 0 > /sys/kernel/debug/iommu/intel/dmar0/strict

Default Domain 정책 (커널 6.x)

커널 6.x부터 IOMMU default domain 정책이 디바이스별로 세분화되었습니다:

/* sysfs로 디바이스별 도메인 유형 확인/변경 */
$ cat /sys/bus/pci/devices/0000:03:00.0/iommu_group/type
DMA

/* 도메인 유형 변경 (모든 디바이스가 unbind 상태여야) */
$ echo identity > /sys/bus/pci/devices/0000:03:00.0/iommu_group/type

/* 가능한 값: DMA, DMA-FQ, identity */

SWIOTLB 바운스 버퍼

SWIOTLB(Software I/O TLB)는 DMA 주소 제한을 소프트웨어적으로 해결하는 바운스 버퍼 메커니즘입니다.

사용 조건

설정과 모니터링

/* 부팅 파라미터 */
swiotlb=65536        /* 슬랩 수 (기본 64MB = 32768 × 2KB) */
swiotlb=force         /* 강제 사용 (디버깅) */
swiotlb=noforce       /* 비활성화 */

/* 모니터링 */
$ cat /sys/kernel/debug/swiotlb/io_tlb_nslabs   /* 전체 슬랩 수 */
$ cat /sys/kernel/debug/swiotlb/io_tlb_used      /* 사용 중 슬랩 수 */
$ dmesg | grep -i swiotlb                         /* 부팅 로그 확인 */

기밀 컴퓨팅과 SWIOTLB

AMD SEV/Intel TDX 환경에서는 게스트 메모리가 암호화되어 있어 디바이스가 직접 접근할 수 없습니다. SWIOTLB가 공유(비암호화) 바운스 버퍼를 통해 데이터를 중계합니다:

CMA (Contiguous Memory Allocator)

CMA는 물리적으로 연속된 대용량 메모리를 런타임에 할당할 수 있게 하는 메커니즘입니다. IOMMU가 없는 임베디드 시스템에서 DMA 버퍼 할당에 특히 중요합니다.

CMA와 DMA의 관계

IOMMU가 없으면 물리적으로 연속된 메모리가 DMA에 필수입니다. CMA는 부팅 시 예약된 영역을 평상시 이동 가능(movable) 페이지로 사용하다가, DMA 요청 시 페이지를 이주(migrate)시키고 연속 블록을 확보합니다.

/* DMA 할당이 CMA를 자동 사용하는 경로 */
dma_alloc_coherent(dev, size, &handle, GFP_KERNEL)
  → dma_alloc_attrs()
    → dma_direct_alloc()  /* IOMMU 없는 경우 */
      → dma_alloc_from_contiguous()
        → cma_alloc()  /* CMA 영역에서 할당 */

CMA 설정

/* 커널 부팅 파라미터 */
cma=256M              /* 기본 CMA 영역 크기 */
cma=256M@0-4G        /* 4GB 이하에 256MB 예약 (32비트 DMA) */

/* Device Tree 설정 (ARM/임베디드) */
reserved-memory {
    #address-cells = <1>;
    #size-cells = <1>;
    ranges;

    linux,cma {
        compatible = "shared-dma-pool";
        reusable;
        size = <0x10000000>;  /* 256MB */
        linux,cma-default;
    };

    /* 디바이스 전용 CMA */
    gpu_cma: gpu_reserved {
        compatible = "shared-dma-pool";
        reusable;
        reg = <0x50000000 0x8000000>;  /* 128MB at 1.25GB */
    };
};

gpu@10000000 {
    memory-region = <&gpu_cma>;  /* 디바이스별 CMA 연결 */
};

/* CMA 상태 모니터링 */
$ cat /proc/meminfo | grep Cma
CmaTotal:         262144 kB
CmaFree:          245760 kB

$ cat /sys/kernel/debug/cma/cma-*/count   /* 할당 횟수 */
$ cat /sys/kernel/debug/cma/cma-*/used    /* 사용 중 페이지 */

DMA-BUF 버퍼 공유

DMA-BUF는 서로 다른 디바이스 드라이버 간 DMA 버퍼를 파일 디스크립터(fd)로 공유하는 커널 프레임워크입니다. GPU 렌더링 결과를 디스플레이 컨트롤러·비디오 인코더·카메라와 제로카피로 공유하는 데 핵심적입니다.

Exporter: dma_buf_ops

#include <linux/dma-buf.h>

static const struct dma_buf_ops my_dmabuf_ops = {
    .attach      = my_attach,       /* importer 연결 시 */
    .detach      = my_detach,
    .map_dma_buf = my_map_dma_buf,  /* SG 테이블 제공 */
    .unmap_dma_buf = my_unmap_dma_buf,
    .release     = my_release,      /* 마지막 참조 해제 */
    .mmap        = my_mmap,         /* 유저스페이스 mmap */
    .vmap        = my_vmap,         /* 커널 가상 매핑 */
};

/* DMA-BUF 내보내기 */
DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
exp_info.ops  = &my_dmabuf_ops;
exp_info.size = buf_size;
exp_info.priv = my_private_data;

struct dma_buf *dmabuf = dma_buf_export(&exp_info);
int fd = dma_buf_fd(dmabuf, O_CLOEXEC);  /* fd로 변환 → 유저스페이스에 전달 */

Importer: 버퍼 가져오기

/* fd에서 dma_buf 획득 */
struct dma_buf *dmabuf = dma_buf_get(fd);

/* 디바이스에 연결 */
struct dma_buf_attachment *attach = dma_buf_attach(dmabuf, dev);

/* SG 테이블 획득 — 디바이스가 DMA로 접근할 주소 */
struct sg_table *sgt = dma_buf_map_attachment(attach, DMA_FROM_DEVICE);

/* 디바이스에 SG 주소 프로그래밍, DMA 전송 수행 */

/* 해제 */
dma_buf_unmap_attachment(attach, sgt, DMA_FROM_DEVICE);
dma_buf_detach(dmabuf, attach);
dma_buf_put(dmabuf);

dma_fence와 dma_resv

dma_fence는 비동기 GPU/DMA 작업의 완료를 시그널링하는 동기화 프리미티브입니다. dma_resv(reservation object)는 DMA-BUF당 하나씩 내장되어 있으며, 여러 fence를 관리합니다.

/* fence 대기 */
struct dma_resv *resv = dmabuf->resv;

/* 모든 exclusive fence 대기 (쓰기 완료 대기) */
ret = dma_resv_wait_timeout(resv, DMA_RESV_USAGE_WRITE,
                             true, MAX_SCHEDULE_TIMEOUT);

/* implicit sync: 커널이 자동으로 fence를 삽입/확인 */
/* explicit sync: DRM_IOCTL_SYNCOBJ_* 등으로 유저스페이스가 직접 관리 */

DMA-BUF Heaps

유저스페이스에서 직접 DMA 가능한 버퍼를 할당하는 인터페이스입니다. Android ION 할당자의 후속:

/* 유저스페이스 예시 */
int heap_fd = open("/dev/dma_heap/system", O_RDWR);
struct dma_heap_allocation_data data = {
    .len = 4096,
    .fd_flags = O_CLOEXEC | O_RDWR,
};
ioctl(heap_fd, DMA_HEAP_IOCTL_ALLOC, &data);
/* data.fd — DMA-BUF fd를 받음 */

Android: ION에서 DMA-BUF Heaps로

Android는 GPU, 카메라, 디스플레이 등 다중 디바이스 간 버퍼 공유를 위해 독자적인 ION allocator를 사용했다. ION은 힙 유형별(system, CMA, carveout 등) 메모리 할당과 캐시 관리를 제공했으나, 메인라인에 통합되지 못하고 staging에 머물렀다.

커널 5.6부터 ION의 기능을 메인라인 DMA-BUF Heaps 프레임워크로 대체하기 시작했으며, 커널 5.11에서 ION은 완전히 제거되었다. DMA-BUF Heaps는 ION 대비 깔끔한 API와 메인라인 지원이라는 장점이 있다.

/* Android HAL에서의 DMA-BUF Heaps 사용 (Gralloc) */
/* 카메라 HAL이 DMA-BUF를 할당하고, GPU/디스플레이와 공유 */
int heap_fd = open("/dev/dma_heap/system", O_RDWR);
struct dma_heap_allocation_data alloc = { .len = frame_size, .fd_flags = O_RDWR | O_CLOEXEC };
ioctl(heap_fd, DMA_HEAP_IOCTL_ALLOC, &alloc);
/* alloc.fd를 Binder로 GPU/Display HAL에 전달 → 제로카피 공유 */

Android의 DMA-BUF 활용, Gralloc HAL 구조, 카메라/GPU 버퍼 공유 등 심화 내용은 Android 커널 — HAL과 커널 인터페이스를 참고하라.

DMA Engine 프레임워크

DMA Engine(dmaengine)은 SoC 내장 DMA 컨트롤러를 추상화하는 커널 서브시스템입니다. 버스마스터 DMA와 달리, 별도의 DMA 컨트롤러 하드웨어가 CPU를 대신하여 메모리↔메모리 또는 메모리↔페리퍼럴 데이터 전송을 수행합니다. SPI, I2C, UART, 오디오 코덱, NAND 플래시 등 임베디드 페리퍼럴에서 광범위하게 사용됩니다.

아키텍처 개요

전송 유형

클라이언트 API — 전형적인 Slave DMA 흐름

#include <linux/dmaengine.h>

struct dma_chan *chan;
struct dma_async_tx_descriptor *desc;
struct dma_slave_config cfg;
dma_cookie_t cookie;

/* ① 채널 획득 (Device Tree binding 기반) */
chan = dma_request_chan(dev, "tx");
if (IS_ERR(chan))
    return PTR_ERR(chan);

/* ② 슬레이브 설정 — 방향, FIFO 주소, 버스 폭 */
memset(&cfg, 0, sizeof(cfg));
cfg.direction     = DMA_MEM_TO_DEV;
cfg.dst_addr      = spi_fifo_phys;     /* 페리퍼럴 FIFO 물리 주소 */
cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
cfg.dst_maxburst  = 16;                /* FIFO burst 크기 */
dmaengine_slave_config(chan, &cfg);

/* ③ 디스크립터 준비 — SG 리스트 기반 */
desc = dmaengine_prep_slave_sg(chan, sg_list, sg_nents,
                               DMA_MEM_TO_DEV,
                               DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
if (!desc) {
    dev_err(dev, "Failed to prepare DMA descriptor\\n");
    goto release;
}

/* ④ 완료 콜백 설정 */
desc->callback = my_dma_complete;
desc->callback_param = priv;

/* ⑤ 디스크립터 제출 (큐에 추가) */
cookie = dmaengine_submit(desc);
if (dma_submit_error(cookie)) {
    dev_err(dev, "DMA submit failed\\n");
    goto release;
}

/* ⑥ DMA 전송 시작 (pending → active) */
dma_async_issue_pending(chan);

/* ⑦ 완료 대기 (또는 콜백으로 비동기 처리) */
enum dma_status status;
status = dma_async_is_tx_complete(chan, cookie, NULL, NULL);

release:
dma_release_channel(chan);

Cyclic DMA — 오디오 스트리밍

순환 DMA는 고정 크기 버퍼를 계속 반복 전송하며, 각 period 완료 시 인터럽트를 발생시킵니다. 오디오 PCM 재생/캡처의 핵심 패턴입니다.

/* Cyclic DMA: 오디오 PCM 재생 */
size_t buf_size = periods * period_size;

desc = dmaengine_prep_dma_cyclic(chan,
    dma_buf_addr,           /* DMA 버퍼 물리 주소 */
    buf_size,               /* 전체 버퍼 크기 */
    period_size,            /* period당 크기 (IRQ 단위) */
    DMA_MEM_TO_DEV,         /* 메모리 → I2S FIFO */
    DMA_PREP_INTERRUPT);    /* period마다 인터럽트 */

desc->callback = audio_period_elapsed;
cookie = dmaengine_submit(desc);
dma_async_issue_pending(chan);

/* 콜백: 각 period 완료 시 호출 */
static void audio_period_elapsed(void *param)
{
    struct snd_pcm_substream *substream = param;
    snd_pcm_period_elapsed(substream);  /* ALSA에 period 완료 통보 */
}

Device Tree DMA 바인딩

/* DTS: 페리퍼럴과 DMA 채널 연결 */
spi0: spi@44000000 {
    compatible = "vendor,spi";
    reg = <0x44000000 0x400>;
    interrupts = <GIC_SPI 35 IRQ_TYPE_LEVEL_HIGH>;
    dmas = <&dma1 11 &dma1 12>;  /* TX: ch11, RX: ch12 */
    dma-names = "tx", "rx";
};

dma1: dma-controller@40020000 {
    compatible = "vendor,dma-controller";
    reg = <0x40020000 0x400>;
    interrupts = <GIC_SPI 56 IRQ_TYPE_LEVEL_HIGH>;
    #dma-cells = <1>;  /* 채널 번호 1개 인자 */
    dma-channels = <8>;
    dma-requests = <16>;
};

P2P DMA (Peer-to-Peer DMA)

PCIe Peer-to-Peer DMA는 두 PCIe 디바이스 간 CPU/시스템 메모리를 거치지 않고 직접 데이터를 전송합니다.

사용 사례

pci_p2pdma API

#include <linux/pci-p2pdma.h>

/* P2P DMA 가능 여부 확인 */
int dist = pci_p2pdma_distance(provider, client, true);
if (dist < 0) {
    dev_warn(dev, "P2P DMA not supported between devices\\n");
    return -ENODEV;
}

/* P2P 메모리 할당 (provider의 BAR에서) */
void *p2p_buf = pci_alloc_p2pmem(provider, size);

/* SG 테이블에 P2P 페이지 설정 */
sg_set_page(&sg[0], virt_to_page(p2p_buf), size, 0);
mapped = dma_map_sg(client_dev, sg, 1, DMA_BIDIRECTIONAL);

/* 해제 */
pci_free_p2pmem(provider, p2p_buf, size);

NUMA 인식 DMA

다중 소켓 서버에서 DMA 성능은 NUMA 토폴로지에 크게 영향받습니다. 디바이스가 연결된 NUMA 노드의 메모리에 DMA 버퍼를 할당하면 QPI/UPI 인터커넥트 트래버설을 피해 지연 시간을 줄이고 대역폭을 극대화할 수 있습니다.

NUMA 인식 DMA 할당

/* 디바이스의 NUMA 노드 확인 */
int node = dev_to_node(dev);
pr_info("Device on NUMA node %d\\n", node);

/* NUMA 노드 인식 메모리 할당 → DMA 매핑 */
buf = kmalloc_node(size, GFP_KERNEL, node);
dma_handle = dma_map_single(dev, buf, size, DMA_TO_DEVICE);

/* 또는 페이지 단위 */
page = alloc_pages_node(node, GFP_KERNEL, order);
dma_handle = dma_map_page(dev, page, 0, size, DMA_FROM_DEVICE);

/* dma_alloc_coherent()는 자동으로 디바이스의 NUMA 노드에서 할당 시도 */

/* 인터럽트 CPU 어피니티도 같은 NUMA 노드로 설정 */
irq_set_affinity_hint(irq, cpumask_of_node(node));

NUMA DMA 성능 최적화 체크리스트

가상화와 DMA

가상화 환경에서 DMA는 추가적인 주소 변환 계층과 보안 과제를 수반합니다. 게스트의 DMA 요청이 호스트 물리 메모리에 올바르게 도달하려면 IOMMU의 2단계 변환 또는 paravirtualized DMA가 필요합니다.

가상화 DMA 모드

virtio DMA 경로

virtio 디바이스는 virtqueue(공유 메모리 링)를 통해 게스트↔호스트 데이터를 교환합니다. 게스트 내 DMA 매핑은 SWIOTLB 또는 IOMMU를 통해 처리됩니다.

VFIO 디바이스 Passthrough

/* SR-IOV VF를 게스트에 직접 할당하는 절차 */

/* ① SR-IOV VF 생성 */
$ echo 4 > /sys/bus/pci/devices/0000:03:00.0/sriov_numvfs

/* ② VF를 vfio-pci 드라이버에 바인딩 */
$ echo 0000:03:02.0 > /sys/bus/pci/devices/0000:03:02.0/driver/unbind
$ echo vfio-pci > /sys/bus/pci/devices/0000:03:02.0/driver_override
$ echo 0000:03:02.0 > /sys/bus/pci/drivers/vfio-pci/bind

/* ③ IOMMU 그룹 확인 */
$ readlink /sys/bus/pci/devices/0000:03:02.0/iommu_group
/* ../../../kernel/iommu_groups/15 */

/* ④ QEMU에 VF 전달 */
$ qemu-system-x86_64 ... \
    -device vfio-pci,host=0000:03:02.0

기밀 컴퓨팅 DMA (TDX/SEV)

AMD SEV-SNP와 Intel TDX에서 게스트 메모리는 암호화되어 디바이스가 직접 읽을 수 없습니다. DMA는 반드시 공유(비암호화) 메모리를 통해 이루어지며, 커널은 이를 SWIOTLB로 자동 처리합니다.

/* TDX/SEV 환경에서의 SWIOTLB 동작 (커널 내부) */
/* 1. DMA 매핑 시 원본이 private(암호화) 메모리이면 */
/* 2. SWIOTLB shared 풀에서 바운스 버퍼 할당 */
/* 3. 원본 → 바운스: 복호화 복사 */
/* 4. 디바이스는 바운스 버퍼(비암호화)에서 DMA */
/* 5. 수신: 바운스 → 원본: 암호화 복사 */

/* 부팅 시 SWIOTLB 크기 증가 필요 (기본 64MB → 256MB+) */
/* TDX 게스트는 자동으로 swiotlb=force 설정 */
$ dmesg | grep -i swiotlb
[    0.001] software IO TLB: SWIOTLB bounce buffer size adjusted to 256MB

DMA 보안

DMA 공격 벡터

IOMMU 보호

IOMMU는 DMA 보안의 핵심입니다. 디바이스가 접근 가능한 메모리 영역을 제한합니다:

/* IOMMU strict 모드 강제 (보안 최우선) */
/* 커널 파라미터: iommu.passthrough=0 iommu.strict=1 */

/* Thunderbolt/외장 디바이스 연결 시 IOMMU 보호 확인 */
$ dmesg | grep -i iommu
[    0.123] DMAR: IOMMU enabled
[    1.456] thunderbolt 0-1: IOMMU DMA protection enabled

Thunderbolt/USB4 DMA 보호

Thunderbolt는 PCIe 터널링을 지원하므로 외부 디바이스가 시스템 메모리에 DMA 접근할 수 있습니다. 이는 심각한 보안 위협입니다.

/* Thunderbolt 보안 레벨 확인 */
$ cat /sys/bus/thunderbolt/devices/domain0/security
secure

/* Kernel DMA Protection 상태 확인 */
$ dmesg | grep -i "kernel dma protection"
[    0.000] Kernel DMA protection enabled

/* IOMMU가 Thunderbolt 디바이스를 격리하는지 확인 */
$ dmesg | grep -i thunderbolt | grep -i iommu
[    2.345] thunderbolt 0-1: IOMMU DMA protection enabled

DMA TOCTOU 공격과 방어

TOCTOU(Time-of-Check to Time-of-Use)는 CPU가 DMA 버퍼의 데이터를 검증한 후, 악의적 디바이스가 DMA로 데이터를 변경하는 공격입니다. Thunderbolt, FireWire 등 외부 디바이스에서 발생 가능합니다.

/* ❌ 취약한 코드: 공유 DMA 버퍼에서 직접 검증 */
if (dma_buf->length <= MAX_SIZE) {  /* 검증 시점 */
    /* 디바이스가 여기서 length를 0xFFFFFFFF로 변경! */
    memcpy(dst, dma_buf->data, dma_buf->length);  /* 사용 시점: 버퍼 오버플로! */
}

/* ✅ 안전한 코드: 바운스 버퍼로 복사 후 검증 */
size_t len;
memcpy(&local_header, dma_buf, sizeof(local_header));  /* 로컬 복사 */
len = local_header.length;  /* 로컬 변수 사용 */
if (len <= MAX_SIZE) {
    memcpy(dst, dma_buf->data, len);  /* 안전: len은 디바이스가 변경 불가 */
}

Restricted DMA (Device Tree)

IOMMU가 없는 임베디드 시스템에서 restricted-dma-pool을 사용하여 디바이스 DMA 접근 범위를 제한합니다:

reserved-memory {
    restricted_dma: restricted-dma {
        compatible = "restricted-dma-pool";
        size = <0x0 0x400000>;   /* 4MB */
    };
};

pcie@10000000 {
    memory-region = <&restricted_dma>;
    /* 이 디바이스의 DMA는 지정된 영역으로 제한 */
};

DMA 디버깅과 최적화

DMA_API_DEBUG

커널 빌드 시 CONFIG_DMA_API_DEBUG=y를 활성화하면 DMA API 오용을 런타임에 탐지합니다:

/* 탐지하는 오류 유형 */
/* - map/unmap 짝 불일치 */
/* - 이미 해제된 DMA 매핑에 접근 */
/* - 잘못된 방향(direction) 사용 */
/* - sync 호출 없이 CPU/디바이스 간 전환 */
/* - dma_mapping_error() 미확인 */

/* 활성화 */
$ echo 1 > /sys/kernel/debug/dma-api/enable

/* 로그 확인 */
$ dmesg | grep DMA-API
DMA-API: device driver tries to free DMA memory it has not allocated

/* 매핑 통계 */
$ cat /sys/kernel/debug/dma-api/num_errors
$ cat /sys/kernel/debug/dma-api/driver_filter  /* 특정 드라이버만 추적 */

성능 최적화 가이드

Tracepoint / ftrace 디버깅

DMA 서브시스템은 다양한 tracepoint를 제공하여 매핑/언매핑/바운스 등의 이벤트를 실시간 추적할 수 있습니다.

/* 사용 가능한 DMA 관련 tracepoint 확인 */
$ ls /sys/kernel/debug/tracing/events/dma/
dma_map_page  dma_unmap_page  dma_map_sg  dma_unmap_sg
dma_alloc  dma_free  dma_map_resource  dma_sync_single

/* DMA 매핑 추적 활성화 */
$ echo 1 > /sys/kernel/debug/tracing/events/dma/enable
$ cat /sys/kernel/debug/tracing/trace_pipe

/* 출력 예시 */
nvme0n1-23 [003] .... 1234.567: dma_map_sg: dev=0000:04:00.0 nents=32 mapped=1
nvme0n1-23 [003] .... 1234.568: dma_unmap_sg: dev=0000:04:00.0 nents=32

/* SWIOTLB 바운스 추적 */
$ echo 1 > /sys/kernel/debug/tracing/events/swiotlb/enable
$ cat /sys/kernel/debug/tracing/trace_pipe
/* swiotlb_bounce가 빈번하면 IOMMU 활성화 또는 DMA 마스크 확인 */

/* IOMMU 관련 tracepoint */
$ ls /sys/kernel/debug/tracing/events/iommu/
map  unmap  io_page_fault  attach_device  detach_device

/* IOMMU 페이지 폴트 추적 */
$ echo 1 > /sys/kernel/debug/tracing/events/iommu/io_page_fault/enable
/* io_page_fault 발생 시: 디바이스가 매핑되지 않은 IOVA에 접근 시도 */

성능 분석 도구

/* bpftrace: DMA 매핑 지연 측정 */
$ bpftrace -e '
kprobe:dma_map_sg_attrs { @start[tid] = nsecs; }
kretprobe:dma_map_sg_attrs /@start[tid]/ {
    @latency_us = hist((nsecs - @start[tid]) / 1000);
    delete(@start[tid]);
}'

/* DMA-BUF 전체 할당 현황 */
$ cat /sys/kernel/debug/dma_buf/bufinfo
/* Dma-buf Objects:
   size    flags   mode    count   exp_name
   4194304 00000002 00080007 3      i915    */

/* IOMMU 그룹별 디바이스와 도메인 정보 */
$ find /sys/kernel/iommu_groups/ -type l | while read l; do
    echo "$(dirname $l): $(readlink $l)"; done

핵심 주의사항 10가지

실전 예제

네트워크 드라이버 — Ring Buffer DMA

고성능 NIC 드라이버의 전형적인 DMA 패턴입니다:

struct my_ring {
    struct my_desc *desc;       /* coherent: 디스크립터 링 */
    dma_addr_t      desc_dma;   /* 디스크립터 링 DMA 주소 */
    struct my_buf  *buf;        /* 패킷 버퍼 메타 정보 */
    int             count;
};

/* 초기화: 디스크립터 링은 coherent 할당 */
static int my_ring_alloc(struct device *dev, struct my_ring *ring)
{
    size_t desc_size = ring->count * sizeof(struct my_desc);

    ring->desc = dma_alloc_coherent(dev, desc_size,
                                     &ring->desc_dma, GFP_KERNEL);
    if (!ring->desc)
        return -ENOMEM;

    ring->buf = kcalloc(ring->count, sizeof(*ring->buf), GFP_KERNEL);
    if (!ring->buf) {
        dma_free_coherent(dev, desc_size, ring->desc, ring->desc_dma);
        return -ENOMEM;
    }
    return 0;
}

/* 수신: 패킷 버퍼는 streaming 매핑 */
static int my_rx_alloc_buf(struct device *dev, struct my_ring *ring, int idx)
{
    struct page *page = alloc_page(GFP_KERNEL);
    dma_addr_t dma;

    if (!page)
        return -ENOMEM;

    dma = dma_map_page(dev, page, 0, PAGE_SIZE, DMA_FROM_DEVICE);
    if (dma_mapping_error(dev, dma)) {
        __free_page(page);
        return -EIO;
    }

    ring->buf[idx].page = page;
    ring->buf[idx].dma  = dma;

    /* coherent 디스크립터에 DMA 주소 기록 */
    ring->desc[idx].addr = cpu_to_le64(dma);
    ring->desc[idx].len  = cpu_to_le16(PAGE_SIZE);
    return 0;
}

/* NAPI 수신 처리 */
static int my_rx_poll(struct napi_struct *napi, int budget)
{
    struct my_ring *ring = container_of(napi, ...);
    int processed = 0;

    while (processed < budget) {
        struct my_desc *desc = &ring->desc[ring->next];
        if (!(desc->status & DESC_DONE))
            break;

        /* CPU가 읽기 전 sync */
        dma_sync_single_for_cpu(dev, ring->buf[ring->next].dma,
                                PAGE_SIZE, DMA_FROM_DEVICE);

        /* 패킷 데이터 처리 후 디바이스에 반환 */
        dma_sync_single_for_device(dev, ring->buf[ring->next].dma,
                                   PAGE_SIZE, DMA_FROM_DEVICE);
        processed++;
    }
    return processed;
}

블록 디바이스 — Scatter-Gather DMA

static blk_status_t my_blk_submit(struct blk_mq_hw_ctx *hctx,
                                     const struct blk_mq_queue_data *bd)
{
    struct request *rq = bd->rq;
    struct scatterlist *sg;
    struct req_iterator iter;
    struct bio_vec bvec;
    int nents = 0, mapped;

    /* bio에서 SG 리스트 구성 */
    sg_init_table(sg_list, MAX_SG);
    rq_for_each_segment(bvec, rq, iter) {
        sg_set_page(&sg_list[nents], bvec.bv_page,
                    bvec.bv_len, bvec.bv_offset);
        nents++;
    }

    /* DMA 매핑 */
    mapped = dma_map_sg(dev, sg_list, nents,
                        rq_data_dir(rq) == WRITE ?
                        DMA_TO_DEVICE : DMA_FROM_DEVICE);
    if (!mapped)
        return BLK_STS_IOERR;

    /* 하드웨어 SG 디스크립터 프로그래밍 */
    for_each_sg(sg_list, sg, mapped, i) {
        hw_desc[i].addr = sg_dma_address(sg);
        hw_desc[i].len  = sg_dma_len(sg);
    }

    start_hw_transfer(hw_desc, mapped);
    return BLK_STS_OK;
}

SPI + DMA Engine — 임베디드 전송

SPI 마스터 드라이버가 DMA Engine을 사용하여 대용량 SPI 전송을 수행하는 패턴입니다.

static int my_spi_transfer_dma(struct spi_master *master,
                                 struct spi_transfer *xfer)
{
    struct my_spi *priv = spi_master_get_devdata(master);
    struct dma_async_tx_descriptor *desc;
    dma_cookie_t cookie;

    /* TX DMA 설정 */
    struct dma_slave_config tx_cfg = {
        .direction      = DMA_MEM_TO_DEV,
        .dst_addr       = priv->phys_base + SPI_TX_FIFO,
        .dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE,
        .dst_maxburst   = priv->fifo_depth / 2,
    };
    dmaengine_slave_config(priv->tx_chan, &tx_cfg);

    /* SG 리스트로 전송 준비 */
    sg_init_one(&priv->tx_sg, xfer->tx_buf, xfer->len);
    dma_handle = dma_map_sg(priv->dev, &priv->tx_sg, 1, DMA_TO_DEVICE);

    desc = dmaengine_prep_slave_sg(priv->tx_chan, &priv->tx_sg, 1,
                                   DMA_MEM_TO_DEV, DMA_PREP_INTERRUPT);
    desc->callback = my_spi_dma_done;
    desc->callback_param = priv;

    cookie = dmaengine_submit(desc);
    dma_async_issue_pending(priv->tx_chan);

    /* SPI 하드웨어에 DMA 모드 활성화 */
    writel(SPI_DMA_TX_EN, priv->regs + SPI_DMA_CTRL);

    return 0;
}

디바이스 probe — DMA 설정 패턴

static int my_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{
    struct device *dev = &pdev->dev;
    int ret;

    /* ① PCI 활성화 + 버스마스터 설정 */
    ret = pcim_enable_device(pdev);
    if (ret)
        return ret;
    pci_set_master(pdev);

    /* ② DMA 마스크 설정 */
    ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64));
    if (ret) {
        ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
        if (ret)
            return ret;
    }

    /* ③ Coherent DMA 할당 (디스크립터 링) */
    priv->desc_ring = dma_alloc_coherent(dev, DESC_RING_SIZE,
                                          &priv->desc_dma, GFP_KERNEL);
    if (!priv->desc_ring)
        return -ENOMEM;

    /* ④ DMA Pool 생성 (소형 명령 버퍼) */
    priv->cmd_pool = dma_pool_create("my_cmd", dev, 64, 64, 0);
    if (!priv->cmd_pool) {
        dma_free_coherent(dev, DESC_RING_SIZE,
                          priv->desc_ring, priv->desc_dma);
        return -ENOMEM;
    }

    /* ⑤ 디바이스 초기화 및 인터럽트 등록 */
    ...
    return 0;
}

제로카피와 DMA

제로카피(Zero-Copy)는 CPU가 데이터를 복사하지 않고 DMA만으로 데이터를 전달하는 기법입니다. 네트워킹과 스토리지에서 CPU 사용률을 극적으로 줄입니다.

제로카피 기법 비교

sendfile() / splice() DMA 경로

/* sendfile(): 디스크 → NIC 제로카피 */
/* 커널 내부 경로: */
/* 1. do_sendfile() → splice_file_to_pipe() */
/* 2. Page Cache 페이지를 파이프에 참조 추가 (복사 없음) */
/* 3. pipe_to_sendpage() → tcp_sendpage() */
/* 4. Page Cache 페이지를 sk_buff의 frag로 등록 */
/* 5. NIC가 SG DMA로 Page Cache 페이지를 직접 전송 */

/* 유저스페이스 사용 */
off_t offset = 0;
sendfile(sock_fd, file_fd, &offset, file_size);

/* NIC 요구사항: NETIF_F_SG + NETIF_F_HIGHDMA 필요 */
$ ethtool -k eth0 | grep scatter-gather
scatter-gather: on

MSG_ZEROCOPY 송신

/* 소켓 옵션 활성화 */
int val = 1;
setsockopt(fd, SOL_SOCKET, SO_ZEROCOPY, &val, sizeof(val));

/* 유저 버퍼를 직접 DMA로 전송 */
send(fd, user_buf, len, MSG_ZEROCOPY);

/* NIC DMA 완료 시 errqueue로 통보 → 유저 버퍼 해제 가능 시점 알림 */
struct msghdr msg = {};
struct cmsghdr *cm;
char cbuf[64];
msg.msg_control = cbuf;
msg.msg_controllen = sizeof(cbuf);

recvmsg(fd, &msg, MSG_ERRQUEUE);
cm = CMSG_FIRSTHDR(&msg);
/* cm->cmsg_type == SO_EE_ORIGIN_ZEROCOPY → 완료 통보 */

DMA 완료 통보 메커니즘

DMA 전송 완료를 CPU에 알리는 방법은 성능과 지연 시간의 핵심 요소입니다.

완료 통보 방식

/* 인터럽트 방식 — 기본 패턴 */
static irqreturn_t my_irq_handler(int irq, void *data)
{
    struct my_dev *priv = data;
    u32 status = readl(priv->regs + IRQ_STATUS);

    if (status & DMA_COMPLETE) {
        writel(DMA_COMPLETE, priv->regs + IRQ_ACK);
        dma_unmap_single(priv->dev, priv->dma_handle,
                         priv->len, DMA_FROM_DEVICE);
        complete(&priv->done);  /* 대기 중인 스레드 깨움 */
        return IRQ_HANDLED;
    }
    return IRQ_NONE;
}

/* 폴링 방식 — NVMe io_poll */
while (!nvme_cqe_pending(cq)) {
    cpu_relax();  /* hint: 다른 하이퍼스레드에 양보 */
}
dma_rmb();  /* CQE 데이터 읽기 전 배리어 */
process_cqe(cq);

/* 인터럽트 병합 (NIC ethtool 설정) */
$ ethtool -C eth0 rx-usecs 50 rx-frames 64
/* 50μs 또는 64프레임마다 한 번 인터럽트 */

커널 설정 종합 (Kconfig)

DMA 관련 Kconfig 옵션

권장 설정 프로필

DMA API 빠른 참조

가장 자주 사용되는 DMA API를 기능별로 정리합니다.

할당/해제 API

매핑/해제 API

동기화 API

마스크/제한 API

관련 문서

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

• 메모리 관리 (기초) — DMA 메모리 할당
• DMA Engine — DMA 엔진 API
• IOMMU — DMA 주소 변환과 디바이스 격리
• Scatter/Gather I/O — 비연속 메모리의 DMA 전송
• CMA — 연속 메모리 할당자
• 디바이스 드라이버 — 드라이버에서의 DMA 사용
• PCI / PCIe — PCI DMA 매핑