IOMMU (Input-Output Memory Management Unit)

IOMMU를 DMA 주소 변환(Address Translation)과 디바이스 격리(Isolation)를 담당하는 핵심 보안 계층으로 심층 분석합니다. Intel VT-d, AMD-Vi, ARM SMMU의 구조 차이와 페이지 테이블(Page Table) 모델, DMA remapping/interrupt remapping 동작, ATS/PASID/SVA 기반 고급 공유 주소 공간(Address Space), VFIO 가상화(Virtualization) 환경의 격리 보장, 성능 저하를 줄이기 위한 TLB flush 전략, DMA fault 디버깅(Debugging)과 우회 경로(SWIOTLB)까지 고성능 장치와 멀티테넌트 환경에서 필요한 운영 포인트를 다룹니다.

개요

IOMMU(Input-Output Memory Management Unit)는 CPU의 MMU와 유사하게 I/O 디바이스가 메모리에 접근할 때 주소 변환과 보호를 제공합니다.

주요 목적

• DMA Remapping — 디바이스가 사용하는 DMA 주소를 가상화하여 물리 메모리(Physical Memory) 보호
• Interrupt Remapping — 인터럽트(Interrupt) 메시지 보안 강화 (interrupt injection 공격 방지)
• Device Isolation — 디바이스 간 메모리 격리로 보안 강화
• VM Device Passthrough — 가상 머신에 물리 디바이스 직접 할당
• SVA (Shared Virtual Addressing) — CPU와 디바이스가 동일한 가상 주소 공간 공유

하드웨어 구현

IOMMU 아키텍처

주요 구성 요소

IOMMU Domain

IOMMU domain은 동일한 주소 공간을 공유하는 디바이스 그룹입니다.

struct iommu_domain {
    unsigned int type;            /* IOMMU_DOMAIN_* */
    const struct iommu_ops *ops;
    unsigned long pgsize_bitmap;  /* 지원 페이지 크기 */
    struct iommu_domain_geometry geometry;
    void *iova_cookie;            /* IOVA allocator */
    struct iommu_iotlb_gather iotlb_gather;
};

/* Domain Types */
#define IOMMU_DOMAIN_BLOCKED      0  /* 모든 DMA 차단 */
#define IOMMU_DOMAIN_IDENTITY     1  /* 1:1 매핑 (passthrough) */
#define IOMMU_DOMAIN_UNMANAGED    2  /* 수동 관리 (VFIO) */
#define IOMMU_DOMAIN_DMA          3  /* DMA API 통합 */
#define IOMMU_DOMAIN_DMA_FQ       4  /* Flush Queue 최적화 */

IOMMU Group

IOMMU group은 격리 가능한 최소 디바이스 단위입니다. 같은 그룹의 디바이스는 서로를 구분할 수 없습니다.

struct iommu_group {
    int id;
    struct kobject kobj;
    struct kobject *devices_kobj;
    struct list_head devices;      /* 그룹 내 디바이스 */
    struct iommu_domain *domain;
    void *iommu_data;
};

/* IOMMU Group 확인 */
# ls -l /sys/kernel/iommu_groups/
drwxr-xr-x 2 root root 0 Jan  1 00:00 0
drwxr-xr-x 2 root root 0 Jan  1 00:00 1
drwxr-xr-x 2 root root 0 Jan  1 00:00 2

# ls /sys/kernel/iommu_groups/0/devices/
0000:00:00.0  0000:00:00.1

Default Domain 정책

커널은 부팅 시 각 디바이스에 기본 IOMMU domain을 할당합니다. 이 정책은 커널 파라미터와 드라이버 요청에 따라 결정됩니다.

/* Default domain 타입 결정 흐름 */
/*
 * 1. iommu=pt → IOMMU_DOMAIN_IDENTITY (1:1, 변환 없음)
 * 2. iommu.passthrough=1 → IOMMU_DOMAIN_IDENTITY
 * 3. 기본값 → IOMMU_DOMAIN_DMA (DMA API 통합)
 * 4. VFIO가 그룹을 잡으면 → IOMMU_DOMAIN_UNMANAGED
 */

/* sysfs에서 domain 타입 확인/변경 (커널 6.2+) */
# cat /sys/kernel/iommu_groups/1/type
DMA

# 런타임에 identity로 변경 (디바이스에 드라이버가 없을 때만)
# echo identity > /sys/kernel/iommu_groups/1/type

Nested Translation (2단계 변환)

가상화 환경에서 게스트 OS도 IOMMU를 사용할 수 있도록 2단계 주소 변환을 지원합니다. CPU의 EPT/NPT(Extended/Nested Page Tables)와 유사한 개념입니다.

/* Nested domain 할당 (커널 6.7+) */
struct iommu_domain *nested;
nested = iommu_domain_alloc_user(parent_domain,
    IOMMU_HWPT_ALLOC_NEST_PARENT, user_data);

/* Stage 1: 게스트가 관리하는 페이지 테이블 */
/* Stage 2: 호스트가 관리하는 페이지 테이블 */
/* 최종 물리 주소 = Stage2(Stage1(GIOVA)) */

IOMMU Operations

iommu_ops 구조체(Struct)

struct iommu_ops {
    bool (*capable)(enum iommu_cap);
    struct iommu_domain *(*domain_alloc)(unsigned int type);
    void (*domain_free)(struct iommu_domain *domain);

    int (*attach_dev)(struct iommu_domain *domain,
                      struct device *dev);
    void (*detach_dev)(struct iommu_domain *domain,
                        struct device *dev);

    int (*map)(struct iommu_domain *domain,
               unsigned long iova, phys_addr_t paddr,
               size_t size, int prot, gfp_t gfp);
    size_t (*unmap)(struct iommu_domain *domain,
                   unsigned long iova, size_t size,
                   struct iommu_iotlb_gather *gather);

    phys_addr_t (*iova_to_phys)(struct iommu_domain *domain,
                                 dma_addr_t iova);

    struct iommu_device *(*probe_device)(struct device *dev);
    void (*release_device)(struct device *dev);

    void (*iotlb_sync)(struct iommu_domain *domain,
                       struct iommu_iotlb_gather *gather);
    int (*enable_nesting)(struct iommu_domain *domain);

    /* SVA (Shared Virtual Addressing) */
    int (*sva_bind)(struct device *dev, struct mm_struct *mm,
                   void *drvdata);
    void (*sva_unbind)(struct device *dev, struct mm_struct *mm);

    /* Page Request Interface (PRI) */
    int (*page_response)(struct device *dev,
                          struct iommu_fault_event *evt,
                          struct iommu_page_response *msg);
};

IOMMU 매핑

/* IOMMU domain 할당 */
struct iommu_domain *domain;
domain = iommu_domain_alloc(&pci_bus_type);

/* 디바이스를 domain에 연결 */
iommu_attach_device(domain, dev);

/* IOVA → Physical Address 매핑 */
unsigned long iova = 0x100000;
phys_addr_t paddr = virt_to_phys(buffer);
size_t size = PAGE_SIZE;
int prot = IOMMU_READ | IOMMU_WRITE;

iommu_map(domain, iova, paddr, size, prot);

/* IOVA로 물리 주소 조회 */
phys_addr_t phys = iommu_iova_to_phys(domain, iova);

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

/* 디바이스 분리 및 domain 해제 */
iommu_detach_device(domain, dev);
iommu_domain_free(domain);

DMA API 통합 경로

디바이스 드라이버가 dma_map_single()을 호출하면, IOMMU가 활성화된 환경에서는 iommu_dma_ops를 통해 IOVA 할당 → 페이지 테이블 기록 → IOTLB flush가 자동으로 수행됩니다. 이 섹션에서는 DMA API에서 IOMMU 벤더 드라이버까지의 전체 호출 경로를 추적합니다.

iommu_dma_ops 설치 경로

/* drivers/iommu/dma-iommu.c */
/* IOMMU가 디바이스를 probe할 때 DMA ops 설치 */
void iommu_setup_dma_ops(struct device *dev)
{
    /* 1. iommu_probe_device()에서 호출 */
    /* 2. DMA domain이면 iommu_dma_ops 설치 */
    /* 3. IDENTITY domain이면 dma_direct_ops 유지 */
    dev->dma_ops = &iommu_dma_ops;
}

/* iommu_dma_ops 구조체 */
static const struct dma_map_ops iommu_dma_ops = {
    .map_page        = iommu_dma_map_page,
    .unmap_page      = iommu_dma_unmap_page,
    .map_sg          = iommu_dma_map_sg,
    .unmap_sg        = iommu_dma_unmap_sg,
    .alloc           = iommu_dma_alloc,
    .free            = iommu_dma_free,
    .mmap            = iommu_dma_mmap,
};

iommu_dma_map_page() 코드 흐름

static dma_addr_t iommu_dma_map_page(
    struct device *dev, struct page *page,
    unsigned long offset, size_t size,
    enum dma_data_direction dir, unsigned long attrs)
{
    struct iommu_domain *domain = ...;
    phys_addr_t phys = page_to_phys(page) + offset;
    dma_addr_t iova;
    int prot;

    /* 1. IOVA 할당 (rcache → rb-tree fallback) */
    iova = iommu_dma_alloc_iova(domain, size, dma_limit, dev);
    if (!iova)
        return DMA_MAPPING_ERROR;

    /* 2. 보호 속성 결정 */
    prot = dma_info_to_prot(dir, dev_is_dma_coherent(dev), attrs);
    /* DMA_TO_DEVICE → IOMMU_READ */
    /* DMA_FROM_DEVICE → IOMMU_WRITE */
    /* DMA_BIDIRECTIONAL → IOMMU_READ | IOMMU_WRITE */

    /* 3. IOMMU 페이지 테이블에 매핑 기록 */
    ret = iommu_map(domain, iova, phys, size, prot, GFP_ATOMIC);

    /* 4. Strict 모드면 IOTLB flush (lazy면 생략) */
    return iova + offset;
}

dma_direct vs iommu_dma 경로 비교

IOVA 할당자

IOMMU 서브시스템은 디바이스가 사용할 I/O 가상 주소(IOVA)를 관리하기 위해 전용 할당자를 사용합니다. IOVA 할당자는 DMA API(dma_map_*)가 호출될 때 자동으로 IOVA를 할당하고, unmap 시 반환합니다.

IOVA Domain 구조

/* include/linux/iova.h */
struct iova_domain {
    spinlock_t iova_rbtree_lock;
    struct rb_root rbroot;           /* Red-Black Tree로 IOVA 관리 */
    struct rb_node *cached_node;     /* 마지막 할당 노드 캐싱 */
    struct rb_node *cached32_node;   /* 32-bit 장치용 캐시 */
    unsigned long granule;           /* 최소 할당 단위 (보통 PAGE_SIZE) */
    unsigned long start_pfn;         /* IOVA 시작 PFN */
    unsigned long dma_32bit_pfn;     /* 32-bit DMA 경계 */
    struct iova_rcache *rcaches;     /* per-CPU 재활용 캐시 */
};

struct iova {
    struct rb_node node;
    unsigned long pfn_hi;            /* IOVA 범위 상한 PFN */
    unsigned long pfn_lo;            /* IOVA 범위 하한 PFN */
};

IOVA Magazine 캐시(Cache)

IOVA 할당/해제가 빈번한 고성능 네트워크·스토리지 워크로드에서는 RB-tree 잠금 경합(Lock Contention)이 병목(Bottleneck)이 됩니다. 이를 완화하기 위해 per-CPU magazine cache (rcache)를 사용합니다.

/* IOVA 할당 흐름 */
/* 1. per-CPU rcache에서 먼저 시도 (잠금 없음) */
/* 2. 캐시 미스 → RB-tree에서 할당 (spinlock 획득) */
/* 3. 해제 시 rcache에 반환 (캐시 가득 차면 RB-tree로) */

struct iova *iova = alloc_iova(&iovad, size >> iova_shift(&iovad),
                                dma_limit >> iova_shift(&iovad), true);
if (!iova)
    return DMA_MAPPING_ERROR;

/* IOVA 해제 */
free_iova(&iovad, iova->pfn_lo);

IOVA 할당자 심층 분석

IOVA 할당은 DMA 매핑 성능의 핵심 요소입니다. 고빈도 네트워크/스토리지 워크로드에서 초당 수백만 건의 IOVA 할당/해제가 발생하므로, per-CPU magazine cache (rcache)를 통한 잠금(Lock) 없는 빠른 경로가 필수적입니다.

iova_magazine 구조

/* drivers/iommu/iova.c */
#define IOVA_MAG_SIZE    128  /* 매거진당 IOVA 슬롯 수 */

struct iova_magazine {
    unsigned long size;              /* 현재 저장된 IOVA 수 */
    unsigned long pfns[IOVA_MAG_SIZE]; /* IOVA PFN 배열 */
};

struct iova_cpu_rcache {
    spinlock_t lock;
    struct iova_magazine *loaded;    /* 현재 활성 매거진 */
    struct iova_magazine *prev;      /* 이전 매거진 (백업) */
};

struct iova_rcache {
    struct iova_cpu_rcache __percpu *cpu_rcaches;
    struct iova_magazine *depot[MAX_GLOBAL_MAGS]; /* 전역 매거진 풀 */
    unsigned long depot_size;
    spinlock_t depot_lock;
};

/* 크기별 rcache 인덱스: 1 페이지, 2 페이지, ..., 128 페이지 */
/* 요청 크기 → log2 버킷 → 해당 rcache에서 검색 */

alloc_iova_fast() 코드 경로

unsigned long alloc_iova_fast(
    struct iova_domain *iovad,
    unsigned long size,         /* 요청 크기 (페이지 단위) */
    unsigned long limit_pfn,    /* DMA 주소 상한 */
    bool flush_rcache)
{
    unsigned long iova_pfn;

    /* Fast path: per-CPU rcache에서 할당 (잠금 최소) */
    iova_pfn = iova_rcache_get(iovad, size, limit_pfn);
    if (iova_pfn)
        return iova_pfn;

    /* Slow path: rb-tree에서 할당 (spinlock 필요) */
    iova_pfn = __alloc_and_insert_iova_range(iovad, size, limit_pfn);
    return iova_pfn;
}

/* 해제 */
void free_iova_fast(struct iova_domain *iovad,
                     unsigned long pfn, unsigned long size)
{
    /* rcache에 반환 시도 */
    if (iova_rcache_insert(iovad, pfn, size))
        return;

    /* rcache 가득 참 → rb-tree에 직접 반환 */
    free_iova(iovad, pfn);
}

32-bit DMA 별도 경로

32-bit DMA 장치는 4GB 이하 IOVA만 사용할 수 있으므로, iova_domain에 cached32_node를 별도로 유지합니다.

• dma_32bit_pfn = 4GB >> PAGE_SHIFT
• limit_pfn이 dma_32bit_pfn 이하이면 별도 캐시를 사용합니다.
• 이는 32-bit와 64-bit 장치가 혼재할 때 서로의 IOVA 공간을 침범하지 않도록 분리하기 위함입니다.

rb-tree에서 검색 시:

• 64-bit: cached_node부터 탑다운으로 검색합니다.
• 32-bit: cached32_node부터 탑다운으로 검색합니다.

IOMMU Group 형성 알고리즘

IOMMU Group은 하드웨어적으로 격리 가능한 최소 디바이스 집합입니다. 같은 그룹의 디바이스는 서로의 DMA 트래픽을 볼 수 있어, 보안 관점에서 하나의 단위로 취급해야 합니다. 그룹 형성은 PCIe 토폴로지(Topology)와 ACS(Access Control Services) 지원 여부에 의해 결정됩니다.

pci_device_group() 로직

/* drivers/iommu/iommu.c */
struct iommu_group *pci_device_group(struct device *dev)
{
    struct pci_dev *pdev = to_pci_dev(dev);

    /* 1. DMA alias 확인 */
    /*    일부 디바이스는 다른 BDF로 DMA 수행 (quirk) */
    pci_for_each_dma_alias(pdev, get_pci_alias_or_group, &data);

    /* 2. alias 그룹이 이미 있으면 합류 */
    if (data.group)
        return data.group;

    /* 3. PCI Express가 아닌 디바이스 */
    /*    (레거시 PCI: 같은 버스의 모든 장치가 한 그룹) */
    if (!pci_is_pcie(pdev))
        return pci_bus_group(pdev);

    /* 4. Root Port까지 ACS 경로 확인 */
    if (pci_acs_path_enabled(pdev, NULL, REQ_ACS_FLAGS))
        return iommu_group_alloc();  /* 새 독립 그룹 */

    /* 5. ACS 미지원 → 상위 브리지의 기존 그룹에 합류 */
    return find_or_create_bridge_group(pdev);
}

pci_acs_path_enabled() — ACS 체크 체인

/* drivers/pci/acs.c */
bool pci_acs_path_enabled(struct pci_dev *start,
                           struct pci_dev *end,
                           u16 acs_flags)
{
    /* start부터 end(NULL이면 Root Port)까지 경로의
     * 모든 브리지/스위치가 요청된 ACS 비트를 지원하는지 확인 */
    struct pci_dev *pdev = start;
    while (pdev != end) {
        if (!pci_acs_enabled(pdev, acs_flags))
            return false;
        pdev = pci_upstream_bridge(pdev);
    }
    return true;
}

/* 필수 ACS 플래그 */
#define REQ_ACS_FLAGS  (PCI_ACS_SV | PCI_ACS_RR | PCI_ACS_CR | PCI_ACS_UF)
/* SV: Source Validation — 소스 ID 검증 */
/* RR: P2P Request Redirect — P2P 요청을 상위로 리디렉트 */
/* CR: P2P Completion Redirect — P2P 완료를 상위로 리디렉트 */
/* UF: Upstream Forwarding — 상위로 포워딩 차단 */

IOMMU Group 확인 실전

# 시스템의 모든 IOMMU group과 디바이스 목록
for g in /sys/kernel/iommu_groups/*/devices/*; do
    echo "Group $(basename $(dirname $(dirname $g))): $(basename $g)"
done

# ACS 지원 확인
# lspci -vvv -s 01:00.0 | grep -A5 "Access Control Services"
Capabilities: [2d0] Access Control Services
    ACSCap: SrcValid+ TransBlk+ ReqRedir+ CmpltRedir+ UpstreamFwd+ EgressCtrl+ DirectTrans+
    ACSCtl: SrcValid+ TransBlk- ReqRedir+ CmpltRedir+ UpstreamFwd- EgressCtrl- DirectTrans-

# ACS override (보안 위험! 개발/테스트 전용)
# 커널 파라미터: pci=noacs
# 패치: acs_override quirk (비공식)

Intel VT-d

VT-d 데이터 구조

Intel VT-d는 계층적 페이지 테이블 구조를 사용합니다.

VT-d MMIO 레지스터(Register)

/* VT-d 레지스터 오프셋 */
#define DMAR_VER_REG        0x00   /* Version */
#define DMAR_CAP_REG        0x08   /* Capability */
#define DMAR_ECAP_REG       0x10   /* Extended Capability */
#define DMAR_GCMD_REG       0x18   /* Global Command */
#define DMAR_GSTS_REG       0x1c   /* Global Status */
#define DMAR_RTADDR_REG     0x20   /* Root Table Address */
#define DMAR_CCMD_REG       0x28   /* Context Command */
#define DMAR_IVA_REG        0x50   /* Invalidate Address */
#define DMAR_IOTLB_REG      0x58   /* IOTLB Invalidate */
#define DMAR_IRTA_REG       0xb8   /* Interrupt Remapping Table */

/* Capability 비트 */
#define DMA_CAP_SAGAW       ((1 << 8) - 1)  /* Supported AGW */
#define DMA_CAP_CM          (1 << 7)         /* Caching Mode */
#define DMA_CAP_PI          (1 << 59)        /* Posted Interrupts */

DMAR (DMA Remapping)

ACPI DMAR 테이블은 VT-d 하드웨어 유닛을 기술합니다.

/* ACPI DMAR 테이블 파싱 */
# dmesg | grep -i dmar
DMAR: Host address width 39
DMAR: DRHD base: 0x00000000fed90000 flags: 0x1
DMAR: RMRR base: 0x0000000079800000 end: 0x000000007affffff
DMAR: IOMMU enabled

/* 커널 파라미터 */
intel_iommu=on               # VT-d 활성화
intel_iommu=on,sm_on         # Scalable Mode 활성화
intel_iommu=off              # VT-d 비활성화
iommu=pt                     # Pass-through 모드 (성능 우선)

Intel Scalable Mode (확장 모드)

Intel VT-d의 Scalable Mode는 Legacy Mode를 대체하는 확장 아키텍처로, PASID 기반 주소 공간 분리와 First/Second Level 페이지 테이블을 지원합니다. SVA, Nested Translation, Posted Interrupt 등 현대적 기능은 Scalable Mode에서만 동작합니다.

Legacy vs Scalable 모드 비교

PASID Table Entry 구조 (64 bytes)

/* drivers/iommu/intel/pasid.c */
/* PASID Table Entry — 512-bit (64 bytes, 8 × u64) */
struct pasid_entry {
    u64 val[8];
};

/* 주요 필드 (val[0]) */
#define PASID_ENTRY_P       (1ULL << 0)   /* Present */
#define PASID_ENTRY_PGTT    (7ULL << 6)   /* Page Table Type [8:6] */
#define PASID_ENTRY_SRE     (1ULL << 1)   /* Supervisor Request Enable */
#define PASID_ENTRY_EAFE    (1ULL << 7)   /* Execute Access Fault Enable */

/* PGTT (Page Table Type) 값 */
#define PASID_PGTT_FL_ONLY  1   /* First Level Only (SVA) */
#define PASID_PGTT_SL_ONLY  2   /* Second Level Only (DMA) */
#define PASID_PGTT_NESTED   3   /* Nested (FL→SL, 가상화) */
#define PASID_PGTT_PT       4   /* Pass-through (변환 없음) */

/* First Level PT 포인터 (val[2]) */
/* FLPTPTR[63:12] = First Level PML5/PML4 주소 */
/* SVA: 프로세스의 CR3 값을 직접 기록 */

/* Second Level PT 포인터 (val[0]) */
/* SLPTPTR[63:12] = Second Level PML4 주소 */

Scalable Mode 설정 코드

/* drivers/iommu/intel/iommu.c */
static int intel_iommu_init(void)
{
    /* ECAP_SMTS 비트로 Scalable Mode 지원 확인 */
    if (ecap_smts(iommu->ecap)) {
        /* Root Table의 RTADDR_REG[11] = TTM (Translation Table Mode) */
        /* TTM=01: Scalable Mode */
        iommu->root_entry[bus].hi |= ROOT_ENTRY_TABLE_TYPE;
    }
}

/* Scalable Mode Context Entry 설정 */
static int domain_context_mapping_one(...)
{
    /* 128-bit Context Entry 기록 */
    context->lo = PASID_TABLE_ADDR | CONTEXT_PRESENT;
    context->hi = CONTEXT_TT_DEV_IOTLB |  /* ATS 지원 */
                  CONTEXT_PASIDE;            /* PASID 활성화 */
}

IOMMU 페이지 테이블 워크

IOMMU의 페이지 테이블 워크는 IOVA를 물리 주소로 변환하는 핵심 과정입니다. Intel, AMD, ARM 세 아키텍처 모두 계층적 페이지 테이블을 사용하지만, 엔트리 포맷과 레벨 구조가 다릅니다.

Intel 페이지 테이블 워크

/* drivers/iommu/intel/iommu.c */
/* IOVA → PTE 조회 (Second Level) */
static struct dma_pte *pfn_to_dma_pte(
    struct dmar_domain *domain,
    unsigned long pfn,
    int *target_level)
{
    struct dma_pte *parent, *pte;
    int level = agaw_to_level(domain->agaw);

    parent = domain->pgd;  /* PML4 (최상위) */

    while (level > 0) {
        int offset = pfn_level_offset(pfn, level);
        pte = &parent[offset];

        /* 대형 페이지 확인: SP 비트 설정이면 워크 중단 */
        if (dma_pte_superpage(pte) || level == 1) {
            *target_level = level;
            return pte;
        }

        /* 다음 레벨 테이블 주소 추출 */
        parent = phys_to_virt(dma_pte_addr(pte));
        level--;
    }
    return NULL;
}

ARM SMMUv3 Stream Table 구조

/* ARM SMMUv3: Linear vs 2-Level Stream Table */

/* Linear Stream Table: SID 직접 인덱싱 */
/* 크기 = num_sids × 64 bytes (STE 크기) */
/* 적은 디바이스 수에 적합 */

/* 2-Level Stream Table: SID를 2단계로 분해 */
/* L1: SID[N:8] → L1 Descriptor (L2 테이블 주소) */
/* L2: SID[7:0] → STE (Stream Table Entry) */
/* 많은 디바이스에서 메모리 절약 */

struct arm_smmu_ste {
    __le64 data[8];  /* 512-bit (64 bytes) */
};

/* STE → Context Descriptor → TTB (Translation Table Base) */
/* Stage 1: TTB0 → LPAE 워크 (VA→IPA) */
/* Stage 2: VMID + VTTBR → LPAE 워크 (IPA→PA) */

주소 폭(AGAW) 비교

AMD-Vi (AMD I/O Virtualization)

AMD-Vi는 AMD 플랫폼의 IOMMU 구현으로, Intel VT-d와 유사한 기능을 제공하지만 다른 하드웨어 구조를 사용합니다.

AMD-Vi 데이터 구조

AMD-Vi는 Device Table을 사용하여 디바이스별 설정을 관리합니다. Intel의 Root/Context 2단계 구조와 달리, 단일 Device Table에서 BDF(Bus/Device/Function)를 직접 인덱싱합니다.

/* AMD IOMMU Device Table Entry (drivers/iommu/amd/amd_iommu_types.h) */
struct dev_table_entry {
    u64 data[4];   /* 256-bit (32 바이트) */
};

/* DTE 주요 비트 필드 */
#define DTE_FLAG_V       (1ULL << 0)   /* Valid */
#define DTE_FLAG_TV      (1ULL << 1)   /* Translation Valid */
#define DTE_FLAG_IR      (1ULL << 61)  /* Interrupt Remapping */
#define DTE_FLAG_IW      (1ULL << 62)  /* Interrupt Write */
#define DTE_FLAG_IOTLB   (1ULL << 9)   /* IOTLB 지원 (ATS) */
#define DTE_FLAG_GV      (1ULL << 2)   /* Guest Translation Valid (v2) */

AMD-Vi 커널 파라미터

# AMD IOMMU 활성화 (대부분 자동 감지)
amd_iommu=on                  # 명시적 활성화
amd_iommu=off                 # 비활성화
amd_iommu=force_isolation     # 모든 디바이스 격리 강제
iommu=pt                      # pass-through 모드 (Intel/AMD 공통)

# IVRS (I/O Virtualization Reporting Structure) 확인
# dmesg | grep -i amd
AMD-Vi: Found IOMMU at 0000:00:00.2 cap 0x40
AMD-Vi: Interrupt remapping enabled
AMD-Vi: Lazy IO/TLB flushing enabled

Interrupt Remapping

Interrupt remapping은 MSI/MSI-X 인터럽트를 IOMMU가 가로채서 재매핑합니다. 이는 interrupt injection 공격을 방지합니다.

Interrupt Remapping Table Entry (IRTE)

struct irte {
    u64 present       : 1;
    u64 fpd           : 1;   /* Fault Processing Disable */
    u64 dst_mode      : 1;   /* Destination Mode (physical/logical) */
    u64 redir_hint    : 1;   /* Redirection Hint */
    u64 trigger_mode  : 1;   /* Trigger Mode (edge/level) */
    u64 dlvry_mode    : 3;   /* Delivery Mode */
    u64 avail         : 4;
    u64 reserved      : 3;
    u64 irte_mode     : 1;   /* 0=Remapped, 1=Posted */
    u64 vector        : 8;   /* Interrupt Vector */
    u64 reserved2     : 8;
    u64 dest_id       : 32;  /* Destination APIC ID */
};

/* Interrupt remapping 활성화 */
# dmesg | grep -i "interrupt remapping"
DMAR-IR: Enabled IRQ remapping in x2apic mode

Posted Interrupts

Posted Interrupts는 가상화 환경에서 인터럽트를 VM에 직접 전달하여 VM-exit를 줄입니다.

struct pi_desc {
    u32 pir[8];          /* Posted Interrupt Requests (256-bit) */
    u32 control;          /* ON, SN, NV */
    u32 rsvd[7];
} __aligned(64);

/* VT-d Posted Interrupt Descriptor Address */
#define IRTE_PI_ADDR_MASK    0xfffffffffff00000

PASID (Process Address Space ID)

PASID는 단일 디바이스가 여러 주소 공간(프로세스)을 구분할 수 있게 합니다.

PASID Table

struct pasid_entry {
    u64 present       : 1;
    u64 pwt           : 1;   /* Page-level Write-Through */
    u64 pcd           : 1;   /* Page-level Cache Disable */
    u64 reserved      : 9;
    u64 slptptr       : 52;  /* Second Level Page Table Pointer */
    u64 pgtt          : 3;   /* Page Table Type */
    u64 reserved2     : 61;
};

/* PASID 할당 */
int pasid;
pasid = iommu_sva_alloc_pasid(dev, 1, (1 << 20) - 1);

SVA (Shared Virtual Addressing)

SVA는 CPU와 디바이스가 동일한 가상 주소 공간을 공유합니다. CPU의 페이지 테이블을 IOMMU가 직접 사용합니다.

#include <linux/iommu.h>

/* SVA 바인딩 */
struct iommu_sva *sva;
sva = iommu_sva_bind_device(dev, current->mm, NULL);
if (IS_ERR(sva))
    return PTR_ERR(sva);

/* PASID 획득 */
int pasid = iommu_sva_get_pasid(sva);

/* 디바이스는 이제 user space 가상 주소 직접 사용 가능 */
void *user_buf = mmap(...);
device_submit_command(user_buf, pasid);  /* CPU와 동일 VA */

/* SVA 언바인딩 */
iommu_sva_unbind_device(sva);

ATS / PRI (PCIe IOMMU 가속)

ATS(Address Translation Services)와 PRI(Page Request Interface)는 PCIe 디바이스가 IOMMU와 직접 상호작용하여 성능을 높이는 PCIe 확장 기능입니다.

ATS (Address Translation Services)

ATS를 지원하는 디바이스는 IOMMU에 주소 변환을 요청하여 결과를 디바이스 내부 ATC(Address Translation Cache)에 캐싱합니다. 이후 DMA 요청 시 IOMMU 페이지 테이블 워크를 건너뛸 수 있어 레이턴시가 줄어듭니다.

/* ATS 활성화 (drivers/pci/ats.c) */
int pci_enable_ats(struct pci_dev *dev, int ps)
{
    u16 ctrl;
    if (!dev->ats_cap)
        return -EINVAL;

    pci_read_config_word(dev, dev->ats_cap + PCI_ATS_CTRL, &ctrl);
    ctrl |= PCI_ATS_CTRL_ENABLE;
    ctrl |= PCI_ATS_CTRL_STU(ps);    /* Smallest Translation Unit */
    pci_write_config_word(dev, dev->ats_cap + PCI_ATS_CTRL, ctrl);

    dev->ats_enabled = 1;
    return 0;
}

/* ATS 무효화 (IOMMU가 매핑 변경 시) */
void pci_ats_invalidate(struct pci_dev *dev, u16 did,
                         unsigned long addr, unsigned int size);

PRI (Page Request Interface)

PRI는 SVA 환경에서 디바이스가 매핑되지 않은 페이지에 접근할 때 page fault를 발생시키고, OS가 페이지를 할당한 뒤 디바이스에 응답하는 메커니즘입니다. CPU의 demand paging과 유사합니다.

/* PRI 활성화 */
pci_enable_pri(pdev, 32);   /* 최대 32개 outstanding page request */

/* Page Request 처리 흐름 */
/*  1. 디바이스가 IOVA에 접근 → IOMMU 변환 실패 */
/*  2. IOMMU가 Page Request 큐에 이벤트 기록 */
/*  3. 커널이 페이지 할당/매핑 후 Page Response 전송 */
/*  4. 디바이스가 DMA 재시도 */

/* IOMMU 드라이버에서 PRI 이벤트 처리 */
static irqreturn_t priq_event_thread(int irq, void *data)
{
    struct arm_smmu_device *smmu = data;
    /* Page Request Queue에서 이벤트 읽기 */
    /* handle_mm_fault() 호출 → 페이지 할당 */
    /* iommu_page_response() 로 디바이스에 응답 */
    return IRQ_HANDLED;
}

IOPF (I/O Page Fault) 프레임워크

IOPF(I/O Page Fault)는 SVA/PRI 환경에서 디바이스가 매핑되지 않은 가상 주소에 접근할 때 발생하는 복구 가능한 fault를 처리하는 커널 프레임워크입니다. CPU의 demand paging과 유사하게, 디바이스 DMA도 lazy하게 페이지를 할당받을 수 있습니다.

IOPF 주요 구조체

/* drivers/iommu/io-pgfault.c */
struct iopf_fault {
    struct iommu_fault fault;    /* fault 정보 */
    struct list_head list;       /* 그룹 fault 연결 */
};

struct iopf_group {
    struct iopf_fault last_fault; /* 마지막 fault (응답 대상) */
    struct list_head faults;     /* 같은 Group ID의 fault 목록 */
    struct list_head pending;    /* 보류 큐 */
    struct device *dev;
    struct work_struct work;     /* workqueue에서 처리 */
};

/* Fault 유형 */
struct iommu_fault {
    u32 type;                    /* IOMMU_FAULT_DMA_UNRECOV 또는
                                  * IOMMU_FAULT_PAGE_REQ */
    struct iommu_fault_page_request prm; /* page request 정보 */
};

struct iommu_fault_page_request {
    u32 flags;                   /* IOMMU_FAULT_PAGE_REQUEST_PASID_VALID 등 */
    u32 pasid;                   /* 요청 프로세스 PASID */
    u32 grpid;                   /* Group ID (관련 fault 묶기) */
    u32 perm;                    /* 요청 권한 (R/W/X) */
    u64 addr;                    /* fault 주소 (가상 주소) */
};

IOPF 핸들러(Handler) 코드 경로

/* IOMMU 드라이버가 fault 보고 */
iommu_report_device_fault(dev, &fault_evt);
    /* → iopf_group에 fault 추가 */
    /* → last_fault(LPSG=1)이면 workqueue 스케줄 */

/* workqueue에서 실행 */
static void iopf_handler(struct work_struct *work)
{
    struct iopf_group *group = ...;

    /* SVA 핸들러 호출 */
    ret = iommu_sva_handle_iopf(group);
    /* 내부:
     * 1. PASID → mm_struct 조회
     * 2. mmap_read_lock(mm)
     * 3. handle_mm_fault(vma, addr, flags)
     *    → 일반 page fault 처리 (demand paging)
     * 4. mmap_read_unlock(mm)
     */

    /* 응답 전송 */
    struct iommu_page_response resp = {
        .code = ret ? IOMMU_PAGE_RESP_FAILURE
                    : IOMMU_PAGE_RESP_SUCCESS,
        .grpid = group->last_fault.fault.prm.grpid,
        .pasid = group->last_fault.fault.prm.pasid,
    };
    iommu_page_response(dev, &group->last_fault.fault, &resp);
}

IOPF 지원 매트릭스

VFIO (Virtual Function I/O)

VFIO는 IOMMU를 활용하여 userspace에서 안전하게 디바이스를 제어할 수 있게 합니다.

VFIO Container & Group

/* VFIO 사용 예시 (QEMU/KVM) */
# modprobe vfio-pci

# PCI 디바이스를 vfio-pci로 바인딩
# echo 0000:01:00.0 > /sys/bus/pci/devices/0000\:01\:00.0/driver/unbind
# echo 8086 10fb > /sys/bus/pci/drivers/vfio-pci/new_id

# IOMMU group 확인
# readlink /sys/bus/pci/devices/0000:01:00.0/iommu_group
../../../kernel/iommu_groups/1

# QEMU에서 디바이스 패스스루
qemu-system-x86_64 \
  -device vfio-pci,host=01:00.0 \
  ...

VFIO API

#include <linux/vfio.h>

/* VFIO container 열기 */
int container = open("/dev/vfio/vfio", O_RDWR);

/* IOMMU group 열기 */
int group = open("/dev/vfio/1", O_RDWR);

/* Group을 container에 추가 */
ioctl(group, VFIO_GROUP_SET_CONTAINER, &container);

/* IOMMU type 설정 (Type1 = DMA remapping) */
ioctl(container, VFIO_SET_IOMMU, VFIO_TYPE1_IOMMU);

/* DMA 매핑 */
struct vfio_iommu_type1_dma_map dma_map = {
    .argsz = sizeof(dma_map),
    .flags = VFIO_DMA_MAP_FLAG_READ | VFIO_DMA_MAP_FLAG_WRITE,
    .vaddr = (__u64)buffer,
    .iova = 0x100000,
    .size = 4096,
};
ioctl(container, VFIO_IOMMU_MAP_DMA, &dma_map);

Domain Attach/Switch 경로

IOMMU domain의 attach/detach는 디바이스의 DMA 주소 공간을 전환하는 핵심 동작입니다. 부팅 시 DMA domain → VFIO 바인딩 시 UNMANAGED domain → VFIO 해제 시 DMA domain 복귀가 전형적인 라이프사이클입니다.

iommu_attach_device() 내부

/* drivers/iommu/iommu.c */
int iommu_attach_device(struct iommu_domain *domain,
                         struct device *dev)
{
    struct iommu_group *group = dev->iommu_group;

    /* 1. 현재 domain detach */
    __iommu_detach_device(group->domain, dev);

    /* 2. 벤더별 attach 콜백 */
    ret = domain->ops->attach_dev(domain, dev);
    /* Intel: intel_iommu_attach_device()
     *   → context entry 기록 + root table 업데이트
     *   → qi_flush_context() + qi_flush_iotlb()
     * AMD: amd_iommu_attach_device()
     *   → DTE(Device Table Entry) 업데이트
     *   → command buffer로 DTE + IOTLB flush
     * ARM: arm_smmu_attach_dev()
     *   → STE(Stream Table Entry) 업데이트
     *   → CMDQ: CFGI_STE + TLBI_NSNH_ALL */

    /* 3. group->domain 갱신 */
    group->domain = domain;
    return ret;
}

VFIO DMA Owner Claim (커널 5.18+)

/* VFIO가 디바이스 그룹을 점유할 때 */
int iommu_group_claim_dma_owner(struct iommu_group *group,
                                  void *owner)
{
    /* 1. 그룹 내 모든 디바이스가 바인딩된 드라이버 없는지 확인 */
    /*    (커널 드라이버 → vfio-pci로 전환 완료 후 호출) */
    /* 2. 기존 DMA domain detach */
    /* 3. BLOCKED domain 임시 attach (DMA 차단) */
    /* 4. owner 기록 → UNMANAGED domain attach 허용 */
}

/* VFIO 해제 시 */
void iommu_group_release_dma_owner(struct iommu_group *group)
{
    /* 1. UNMANAGED domain detach */
    /* 2. 기본 DMA domain 복원 attach */
    /* 3. owner 해제 */
}

sysfs Domain 타입 전환 (커널 6.2+)

# 현재 domain 타입 확인
# cat /sys/kernel/iommu_groups/3/type
DMA

# DMA → identity 전환 (디바이스에 바인딩된 드라이버 없을 때만)
# echo identity > /sys/kernel/iommu_groups/3/type

# 허용 타입 목록
# cat /sys/kernel/iommu_groups/3/available_types
DMA DMA-FQ identity

# Flush Queue 모드로 전환
# echo DMA-FQ > /sys/kernel/iommu_groups/3/type

ARM SMMU

ARM System Memory Management Unit는 ARM 플랫폼의 IOMMU 구현입니다.

SMMU 아키텍처

SMMU 버전

SMMU 드라이버

/* Device Tree에서 SMMU 정의 */
smmu: iommu@2b400000 {
    compatible = "arm,smmu-v3";
    reg = <0x0 0x2b400000 0x0 0x100000>;
    interrupts = <GIC_SPI 74 IRQ_TYPE_EDGE_RISING>,
                 <GIC_SPI 75 IRQ_TYPE_EDGE_RISING>,
                 <GIC_SPI 76 IRQ_TYPE_EDGE_RISING>;
    interrupt-names = "eventq", "priq", "gerror";
    #iommu-cells = <1>;
};

/* 디바이스가 SMMU 사용 */
pcie@40000000 {
    iommus = <&smmu 0>;  /* Stream ID = 0 */
};

SMMUv3 Command/Event Queue

SMMUv3는 소프트웨어와 하드웨어 간 통신을 위해 3개의 링 버퍼(Ring Buffer) 큐를 사용합니다. Command Queue(CMDQ)는 SW→HW 명령 전달, Event Queue(EVENTQ)는 HW→SW 오류 보고, PRI Queue(PRIQ)는 HW→SW 페이지 요청을 처리합니다.

arm_smmu_queue 구조체

/* drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h */
struct arm_smmu_queue {
    struct arm_smmu_ll_queue llq;   /* prod/cons + max_n_shift */
    dma_addr_t base_dma;             /* 큐 물리 주소 */
    void *base;                       /* 큐 가상 주소 */
    struct arm_smmu_cmdq_ent *entries; /* 엔트리 배열 */
};

struct arm_smmu_ll_queue {
    union {
        u64 val;
        struct {
            u32 prod;              /* Producer 인덱스 + wrap */
            u32 cons;              /* Consumer 인덱스 + wrap */
        };
    };
    u32 max_n_shift;                /* log2(큐 크기) */
};

/* 큐 사이즈: 2^max_n_shift 엔트리 */
/* CMDQ 엔트리: 16 바이트 (128-bit) */
/* EVENTQ/PRIQ 엔트리: 32 바이트 (256-bit) */

CMDQ 주요 Opcode

CMDQ 배치 제출

/* 배치 명령 제출 — 여러 명령을 모아서 한 번에 전송 */
struct arm_smmu_cmdq_batch cmds;
arm_smmu_cmdq_batch_init(smmu, &cmds, &cmd_ent);

/* TLB 무효화 명령 배치 추가 */
for (i = 0; i < nr_pages; i++) {
    cmd_ent.opcode = CMDQ_OP_TLBI_NH_VA;
    cmd_ent.tlbi.asid = asid;
    cmd_ent.tlbi.addr = iova + i * SZ_4K;
    arm_smmu_cmdq_batch_add(smmu, &cmds, &cmd_ent);
}

/* CMD_SYNC를 마지막에 추가 → HW 완료 보장 */
arm_smmu_cmdq_batch_submit(smmu, &cmds);

/* 내부적으로:
 * 1. CMDQ 공간 확보 (CONS 따라잡기 대기)
 * 2. 엔트리 기록 → PROD 전진 (writel)
 * 3. CMD_SYNC 대기 (polling 또는 MSI)
 */

EVENTQ Fault 처리

/* Event Queue 처리 스레드 */
static irqreturn_t arm_smmu_evtq_thread(int irq, void *dev)
{
    struct arm_smmu_device *smmu = dev;
    struct arm_smmu_queue *q = &smmu->evtq.q;
    u64 evt[EVTQ_ENT_DWORDS];   /* 256-bit 이벤트 */

    while (!queue_empty(q)) {
        queue_read(evt, q, q->llq.cons);
        arm_smmu_handle_evt(smmu, evt);
        queue_inc_cons(q);
    }
    return IRQ_HANDLED;
}

/* 이벤트 타입 파싱 */
/* evt[0] bits[7:0] = event ID */
#define EVT_ID_TRANSLATION_FAULT   0x10
#define EVT_ID_ADDR_SIZE_FAULT     0x11
#define EVT_ID_ACCESS_FAULT        0x12
#define EVT_ID_PERMISSION_FAULT    0x13

IOTLB 내부 구조와 무효화

IOTLB(I/O Translation Lookaside Buffer)는 IOMMU의 주소 변환 캐시입니다. CPU의 TLB와 동일한 원리로, 최근 사용된 IOVA→PA 변환 결과를 캐시하여 페이지 테이블 워크를 건너뜁니다. 매핑이 변경되면 반드시 무효화(invalidation)해야 하며, 이 비용이 IOMMU 성능의 핵심 요소입니다.

iommu_iotlb_gather — 범위 누적 배치 flush

/* include/linux/iommu.h */
struct iommu_iotlb_gather {
    unsigned long start;      /* 무효화 시작 IOVA */
    unsigned long end;        /* 무효화 끝 IOVA */
    size_t pgsize;             /* 사용된 페이지 크기 */
    struct list_head freelist; /* 해제할 페이지 테이블 목록 */
    bool queued;               /* Flush Queue 사용 여부 */
};

/* unmap 시 gather에 범위 누적 */
iommu_iotlb_gather_add_range(&gather, iova, size);

/* 모든 unmap 후 한 번에 flush */
iommu_iotlb_sync(domain, &gather);
/* → domain->ops->iotlb_sync() 호출 */
/* → Intel: qi_flush_iotlb(), AMD: amd_iommu_flush_tlb_all() */

Intel Queued Invalidation (QI)

/* drivers/iommu/intel/qi.c */
struct qi_desc {
    u64 qw0;   /* Descriptor Type + 파라미터 */
    u64 qw1;   /* 추가 파라미터 */
    u64 qw2;   /* Wait: status_data */
    u64 qw3;   /* Wait: status_addr */
};

/* IOTLB 무효화 기술자 타입 */
#define QI_IOTLB_TYPE         0x2   /* IOTLB Invalidate */
#define QI_CC_TYPE            0x1   /* Context Cache Invalidate */
#define QI_IEC_TYPE           0x4   /* Interrupt Entry Cache */
#define QI_WAIT_TYPE          0x5   /* Wait Descriptor */
#define QI_PGRP_RESP_TYPE     0x7   /* Page Group Response */

/* 동기식 무효화 흐름 */
int qi_submit_sync(struct intel_iommu *iommu,
                    struct qi_desc *desc,
                    unsigned int count,
                    unsigned long options)
{
    /* 1. QI 큐 tail에 desc 기록 */
    /* 2. Wait Descriptor 추가 (status_data = QI_DONE) */
    /* 3. tail 레지스터 업데이트 → HW 시작 */
    /* 4. status_data가 QI_DONE이 될 때까지 spin/sleep */
}

AMD Command Buffer

/* AMD IOMMU Command Buffer — Intel QI와 유사한 링 버퍼 */
/* drivers/iommu/amd/iommu.c */

/* 주요 명령 타입 */
#define CMD_COMPL_WAIT              0x01  /* Completion Wait */
#define CMD_INV_DEV_ENTRY           0x02  /* Device Table Entry */
#define CMD_INV_IOMMU_PAGES         0x03  /* IOTLB Pages */
#define CMD_INV_IOTLB_PAGES         0x04  /* ATS Invalidation */
#define CMD_COMPLETE_PPR            0x07  /* PPR Response */
#define CMD_INV_IRT                 0x0a  /* Interrupt Remapping */

/* 페이지 무효화 명령 생성 */
static void build_inv_iommu_pages(struct iommu_cmd *cmd,
    u64 address, size_t size, u16 domid, bool pde)
{
    cmd->data[0] = CMD_INV_IOMMU_PAGES | (domid << 32);
    cmd->data[1] = address | (pde ? (1ULL << 1) : 0);
    /* pde=true: PDE 캐시도 함께 무효화 */
}

Flush Queue 동작

/* drivers/iommu/iova.c — Flush Queue (FQ) */
struct iova_fq {
    struct iova_fq_entry entries[IOVA_FQ_SIZE]; /* 256개 엔트리 */
    unsigned int head, tail;
    spinlock_t lock;
};

struct iova_fq_entry {
    unsigned long iova_pfn;
    unsigned long pages;
    u64 counter;              /* 무효화 시점 카운터 */
};

/* FQ 흐름: */
/* 1. unmap → IOVA를 per-CPU FQ에 추가 (flush 보류) */
/* 2. 10ms 타이머 만료 → fq_flush_timeout() */
/* 3. 보류된 범위 일괄 IOTLB flush */
/* 4. IOVA를 rcache에 반환 (재사용 가능) */

크로스 아키텍처 PTE 포맷 비교

IOMMU의 페이지 테이블 엔트리(PTE)는 CPU의 PTE와 유사하지만, 벤더별로 비트 레이아웃이 상이합니다. 이 섹션에서는 Intel VT-d Second Level, AMD I/O PTE, ARM LPAE Stage 2의 비트 필드를 비교합니다.

Intel VT-d PTE 상세

/* drivers/iommu/intel/iommu.h */
/* Second Level PTE — IOMMU 전용 주소 변환 */
#define DMA_PTE_READ         (1ULL << 0)   /* R: 읽기 허용 */
#define DMA_PTE_WRITE        (1ULL << 1)   /* W: 쓰기 허용 */
#define DMA_PTE_LARGE_PAGE   (1ULL << 7)   /* SP: Super Page (2MB/1GB) */
#define DMA_PTE_SNP          (1ULL << 11)  /* Snoop 비트 (캐시 일관성) */
#define DMA_PTE_TM           (1ULL << 62)  /* Transient Mapping */

/* First Level PTE — CPU x86 PTE와 동일 포맷 */
/* SVA에서 CPU 페이지 테이블을 IOMMU가 직접 워크 가능 */
#define FLPTE_PRESENT    (1ULL << 0)
#define FLPTE_WRITE      (1ULL << 1)
#define FLPTE_USER       (1ULL << 2)
#define FLPTE_ACCESSED   (1ULL << 5)
#define FLPTE_DIRTY      (1ULL << 6)
#define FLPTE_NX         (1ULL << 63)

AMD I/O PTE 상세

/* drivers/iommu/amd/amd_iommu_types.h */
#define IOMMU_PTE_PR    (1ULL << 0)   /* Present */
#define IOMMU_PTE_NL_0  (0ULL << 9)   /* Next Level = 0 → 물리 페이지 */
#define IOMMU_PTE_NL_1  (1ULL << 9)   /* Next Level = 1 → 다음 PT 레벨 */
#define IOMMU_PTE_FC    (1ULL << 1)   /* Force Coherency */
#define IOMMU_PTE_IR    (1ULL << 59)  /* I/O Read 허용 */
#define IOMMU_PTE_IW    (1ULL << 60)  /* I/O Write 허용 */

/* AMD 대형 페이지: NL(Next Level) 필드로 인코딩 */
/* NL=0 at Level 2 → 2MB 페이지 */
/* NL=0 at Level 3 → 1GB 페이지 */
/* Intel의 SP 비트와 달리 레벨별 NL=0으로 표현 */

ARM LPAE Stage 2 PTE 상세

/* arch/arm64/include/asm/pgtable-hwdef.h */
#define PTE_VALID        (1ULL << 0)
#define PTE_TYPE_PAGE    (3ULL << 0)   /* [1:0] = 11 → 4KB 페이지 */
#define PTE_TYPE_BLOCK   (1ULL << 0)   /* [1:0] = 01 → 블록 (2MB/1GB) */

/* Stage 2 Access Permissions (S2AP) */
#define PTE_S2AP_NONE    (0ULL << 6)   /* 접근 불가 */
#define PTE_S2AP_READ    (1ULL << 6)   /* 읽기만 */
#define PTE_S2AP_WRITE   (2ULL << 6)   /* 쓰기만 */
#define PTE_S2AP_RW      (3ULL << 6)   /* 읽기+쓰기 */

#define PTE_AF           (1ULL << 10)  /* Access Flag */
#define PTE_CONT         (1ULL << 52)  /* Contiguous (TLB 힌트) */
#define PTE_XN           (1ULL << 54)  /* Execute Never */

/* Contiguous 힌트: 연속 16개 PTE가 같은 속성이면
 * TLB가 하나의 엔트리로 캐시 가능 (16 × 4KB = 64KB)
 * 또는 16 × 2MB = 32MB 블록 */

권한 인코딩 비교

페이지 크기 지원 비교

디버깅

sysfs 인터페이스

# IOMMU 정보 확인
# cat /sys/kernel/iommu_groups/0/type
intel-iommu

# ls /sys/kernel/iommu_groups/0/devices/
0000:00:00.0

# 디바이스별 IOMMU group
# find /sys/kernel/iommu_groups/ -type l | sort -V
/sys/kernel/iommu_groups/0/devices/0000:00:00.0
/sys/kernel/iommu_groups/1/devices/0000:00:02.0

커널 로그

# IOMMU 초기화 로그
# dmesg | grep -i iommu
DMAR: IOMMU enabled
DMAR-IR: Enabled IRQ remapping in x2apic mode
iommu: Default domain type: Translated

# IOMMU fault
DMAR: [DMA Read] Request device [01:00.0] fault addr 0xdeadbeef
DMAR: fault reason 0x06 (PTE Read access is not set)

Tracing

# IOMMU tracepoints
# cd /sys/kernel/debug/tracing
# echo 1 > events/iommu/enable

# 주요 tracepoint
iommu:map                # IOVA 매핑
iommu:unmap              # IOVA 언매핑
iommu:attach_device_to_domain
iommu:detach_device_from_domain

# cat trace
     swapper/0-1 [000] .... 1.234: iommu_map: IOMMU:0000:00:00.0 iova=0x100000 paddr=0x50000000 size=0x1000

성능 고려사항

IOTLB (I/O TLB) 최적화

/* IOTLB 무효화 지연 (Flush Queue) */
#define IOMMU_DOMAIN_DMA_FQ  4  /* Flush Queue 사용 */

/* Strict mode vs Flush Queue */
iommu.strict=0   # Flush Queue 사용 (성능 우선)
iommu.strict=1   # Strict mode (보안 우선, unmap 즉시 IOTLB flush)

Pass-through 모드

/* Pass-through: IOMMU 우회 (1:1 매핑) */
iommu=pt                 # 기본 디바이스는 pass-through

/* 성능 비교 */
/*   Pass-through: DMA latency 최소 */
/*   Translation: 보안 강화, VM passthrough 필요 */

IOMMU 모드 비교

SWIOTLB (소프트웨어 I/O TLB)

SWIOTLB(Software I/O Translation Lookaside Buffer)는 IOMMU가 없거나 디바이스의 DMA 주소 범위가 제한적일 때(예: 32-bit DMA만 지원하는 장치가 4GB 이상 메모리에 접근해야 할 때) 사용하는 바운스 버퍼 메커니즘입니다.

동작 원리

/* SWIOTLB 초기화 (부팅 시 저메모리 영역에 바운스 풀 할당) */
/* 기본 크기: 64MB */
/* 커널 파라미터로 조정: swiotlb=131072  (슬롯 수, 1 슬롯 = 2KB) */

/* DMA 매핑 시 SWIOTLB 사용 경로 */
dma_addr_t swiotlb_map(struct device *dev, phys_addr_t paddr,
                        size_t size, enum dma_data_direction dir)
{
    /* 1. bounce pool에서 슬롯 할당 */
    /* 2. DMA_TO_DEVICE이면 orig → bounce memcpy */
    /* 3. bounce 물리 주소 반환 (디바이스 DMA 범위 내) */
}

/* DMA 완료 후 sync */
void swiotlb_sync_single_for_cpu(struct device *dev,
    dma_addr_t addr, size_t size, enum dma_data_direction dir)
{
    /* DMA_FROM_DEVICE이면 bounce → orig memcpy */
}

DMA Fault 처리

IOMMU가 디바이스의 DMA 요청을 변환하지 못하거나 권한 검증에 실패하면 DMA fault가 발생합니다. 이는 드라이버 버그, 잘못된 IOMMU 설정, 악의적 디바이스 접근 등에 의해 발생할 수 있습니다.

Fault 유형

Fault 핸들러

/* IOMMU fault 핸들러 등록 */
int iommu_set_fault_handler(struct iommu_domain *domain,
                             iommu_fault_handler_t handler,
                             void *token);

/* Fault 콜백 시그니처 */
typedef int (*iommu_fault_handler_t)(struct iommu_domain *domain,
    struct device *dev, unsigned long iova, int flags, void *token);

/* Intel VT-d fault 로그 예시 */
/* DMAR: [DMA Read no-pasid] Request device [01:00.0] */
/*   fault addr 0x3fff0000 [fault reason 0x06] */
/*   PTE Read access is not set */

/* 일반적인 디버깅 단계 */
/* 1. fault addr → 어떤 IOVA가 문제인지 확인 */
/* 2. Request device → 어떤 PCIe 디바이스가 요청했는지 */
/* 3. fault reason → 매핑 누락 / 권한 오류 / 페이지 크기 불일치 */
/* 4. 드라이버의 dma_map_single/dma_map_page 호출 검증 */

커널 설정

CONFIG_IOMMU_SUPPORT=y
CONFIG_IOMMU_API=y

# Intel VT-d
CONFIG_INTEL_IOMMU=y
CONFIG_INTEL_IOMMU_DEFAULT_ON=y
CONFIG_INTEL_IOMMU_SCALABLE_MODE_DEFAULT_ON=y
CONFIG_INTEL_IOMMU_SVM=y              # SVA 지원

# AMD-Vi
CONFIG_AMD_IOMMU=y
CONFIG_AMD_IOMMU_V2=y

# ARM SMMU
CONFIG_ARM_SMMU=y
CONFIG_ARM_SMMU_V3=y
CONFIG_ARM_SMMU_V3_SVA=y

# VFIO
CONFIG_VFIO=y
CONFIG_VFIO_PCI=y
CONFIG_VFIO_IOMMU_TYPE1=y

# 디버깅
CONFIG_IOMMU_DEBUG=y
CONFIG_IOMMU_DEBUGFS=y

참고자료

커널 공식 문서

• Linux IOMMU Documentation — IOMMU 드라이버 API 공식 문서
• x86 IOMMU 지원 — x86 플랫폼 IOMMU 설정 및 부트 옵션
• IOMMU 유저스페이스 API — IOMMU 사용자 공간 인터페이스
• VFIO 드라이버 API — VFIO 프레임워크 공식 문서

커널 소스 코드

• drivers/iommu/iommu.c — IOMMU 코어 프레임워크
• drivers/iommu/iova.c — I/O Virtual Address 할당기
• drivers/iommu/dma-iommu.c — DMA-IOMMU 통합 계층
• drivers/iommu/intel/iommu.c — Intel IOMMU 드라이버
• drivers/iommu/amd/iommu.c — AMD IOMMU 드라이버
• drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c — ARM SMMUv3 드라이버
• drivers/vfio/vfio_iommu_type1.c — VFIO Type1 IOMMU
• include/linux/iommu.h — IOMMU API 정의
• include/linux/iova.h — IOVA 할당기 인터페이스

규격 문서

• Intel VT-d Specification — Intel 가상화 기술 (VT-d)
• ARM SMMU Architecture Specification — ARM 시스템 메모리 관리 유닛
• AMD IOMMU Specification — AMD I/O 가상화 기술 규격

외부 자료

• IOMMU groups (LWN) — IOMMU 그룹 개념 및 격리
• Scalable IOMMU design for the future (LWN) — 확장 가능한 IOMMU 설계
• Shared Virtual Addressing for IOMMU (LWN) — SVA(공유 가상 주소 지정) 기능