DMA 심화 (Direct Memory Access)

Linux 커널 DMA 서브시스템 종합 가이드: 매핑 API(Coherent/Streaming/Scatter-Gather/Pool), IOMMU(VT-d/AMD-Vi/SMMU), SWIOTLB, CMA, DMA-BUF 버퍼 공유, P2P DMA, 캐시 일관성, 보안, 디버깅.

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 할당용 마스크 */

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 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 방향 상수

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

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);

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);

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가 공유(비암호화) 바운스 버퍼를 통해 데이터를 중계합니다:

/* TDX/SEV에서 SWIOTLB 동작 흐름 */
/* 1. 바운스 버퍼는 shared(비암호화) 메모리 영역에 할당 */
/* 2. CPU: 암호화된 원본 → 복호화 → 바운스 버퍼에 복사 */
/* 3. 디바이스: 바운스 버퍼에서 DMA 읽기 */
/* 4. 수신: 디바이스 → 바운스 → 암호화하여 원본에 복사 */

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과 커널 인터페이스를 참고하라.

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);

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

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  /* 특정 드라이버만 추적 */

성능 최적화 가이드

핵심 주의사항 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;
}

디바이스 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;
}

커널 설정 종합 (Kconfig)

DMA 관련 Kconfig 옵션