VFIO & mdev (디바이스 패스스루)

VFIO와 mdev를 고성능 장치 패스스루와 안전한 멀티테넌트 격리(Isolation) 관점에서 심층 분석합니다. IOMMU 기반 DMA 격리와 interrupt remapping, VFIO group/container/device 모델, userspace 드라이버와 QEMU 연동 ioctl 경로, SR-IOV와 full passthrough 비교, mdev를 통한 GPU/가속기 분할 제공 메커니즘, 페이지(Page) 핀 고정과 메모리 회수(Memory Reclaim) 트레이드오프, 리셋·오류 복구·라이브 마이그레이션 제약, 성능 계측과 보안 점검 절차까지 실제 가상화(Virtualization) 플랫폼 운영에서 필요한 핵심을 다룹니다.

VFIO 개요

VFIO는 커널 5.x 이전부터 존재했던 레거시 UIO(Userspace I/O)의 보안 취약점(Vulnerability)을 해결하기 위해 IOMMU와 통합하여 설계된 디바이스 패스스루 프레임워크입니다. VM의 버그나 악성 코드가 DMA를 통해 호스트 메모리에 접근하는 것을 IOMMU가 차단합니다.

VFIO 아키텍처 계층 모델

UIO vs VFIO 비교: 레거시 UIO(drivers/uio/)는 장치를 유저스페이스에 노출하지만 DMA 격리 메커니즘이 없습니다. 악성 프로그램이 DMA를 통해 호스트 커널 메모리를 읽거나 쓸 수 있어 보안 위험이 큽니다. VFIO는 IOMMU를 필수로 요구하여 모든 DMA 접근을 IOVA 주소 공간(Address Space) 내로 제한합니다.

Container/Group/Device 포함 관계:

• Container — 하나의 IOMMU 도메인을 대표합니다. 동일 Container 내 모든 Group은 같은 DMA 매핑(IOVA 공간)을 공유합니다. QEMU는 VM당 하나의 Container를 생성하고, VFIO_SET_IOMMU로 IOMMU 백엔드 타입을 설정합니다.
• Group — IOMMU가 격리할 수 있는 최소 단위입니다. PCIe 토폴로지(Topology)에 의해 결정되며, /dev/vfio/<group_id>를 열어 group_fd를 얻습니다. Group 내 모든 장치가 VFIO에 바인딩되어야 VFIO_GROUP_SET_CONTAINER가 성공합니다.
• Device — Group 내 개별 PCI Function입니다. VFIO_GROUP_GET_DEVICE_FD로 device_fd를 얻은 뒤, 해당 fd를 통해 BAR 매핑, 인터럽트(Interrupt) 설정, 리셋 등 장치 제어를 수행합니다.

IOMMU 그룹과 격리 경계

IOMMU 그룹은 IOMMU가 격리할 수 있는 최소 단위입니다. 같은 PCIe 스위치 아래에 있는 장치들은 P2P DMA 경로를 공유하므로 같은 IOMMU 그룹에 묶입니다. 패스스루를 하려면 IOMMU 그룹 내 모든 장치를 같은 VM에 할당해야 합니다.

# IOMMU 그룹 확인 스크립트
for d in /sys/kernel/iommu_groups/*/devices/*; do
    n=${d#*/iommu_groups/}; n=${n%%/*}
    printf "IOMMU Group %s: " $n
    lspci -nns $(basename $d)
done

# 예시 출력:
# IOMMU Group 14: 01:00.0 VGA [0300]: NVIDIA RTX 4090 [10de:2684]
# IOMMU Group 14: 01:00.1 Audio [0403]: NVIDIA [10de:22ba]
# (GPU와 오디오가 같은 그룹 — 둘 다 패스스루해야 함)

# ACS 지원 확인 (PCIe 루트 포트 ACS 필요)
lspci -vvv | grep -i "Access Control"

# IOMMU 그룹 경계 시각화
find /sys/kernel/iommu_groups -type l | sort -V

ACS (Access Control Services) 메커니즘

ACS는 PCIe 스위치나 루트 포트에서 P2P(Peer-to-Peer) DMA 경로를 차단하여 같은 스위치 아래에 있는 장치들이 서로의 메모리에 접근하지 못하게 합니다. ACS가 없으면 장치 A의 DMA 요청이 IOMMU를 거치지 않고 직접 장치 B의 메모리에 도달할 수 있으며, 이 경우 두 장치는 같은 IOMMU 그룹에 묶여 별도로 패스스루할 수 없습니다.

그룹 격리 실패 사례

/* IOMMU 그룹 조회 및 장치 열거 — 커널 내부 */
#include <linux/iommu.h>

static int check_iommu_group(struct pci_dev *pdev)
{
    struct iommu_group *group;
    int group_id;

    /* 장치의 IOMMU 그룹 가져오기 */
    group = iommu_group_get(&pdev->dev);
    if (!group) {
        dev_err(&pdev->dev, "IOMMU 그룹 없음 — IOMMU 비활성?\n");
        return -ENODEV;
    }

    group_id = iommu_group_id(group);
    dev_info(&pdev->dev, "IOMMU Group %d\n", group_id);

    /* 그룹 내 모든 장치 열거 */
    iommu_group_for_each_dev(group, NULL, print_device_cb);

    /* ACS 상태 확인 */
    if (pci_acs_enabled(pdev, REQ_ACS_FLAGS))
        dev_info(&pdev->dev, "ACS 활성화 — 격리 보장\n");
    else
        dev_warn(&pdev->dev, "ACS 미지원 — P2P DMA 위험\n");

    iommu_group_put(group);
    return 0;
}

/* ACS 오버라이드 — 보안 위험, 테스트 전용 */
/* 커널 파라미터: pcie_acs_override=downstream,multifunction */
/* 이 옵션은 커뮤니티 패치로만 제공 (mainline 미포함) */

VFIO 그룹 API 흐름

VFIO ioctl 시퀀스

#include <linux/vfio.h>

int setup_vfio_device(const char *sysfs_path)
{
    int container_fd, group_fd, device_fd;

    /* 1. Container 열기 (IOMMU 도메인 생성) */
    container_fd = open("/dev/vfio/vfio", O_RDWR);

    /* 2. Group 열기 (IOMMU 그룹 번호는 sysfs에서 확인) */
    /*    /sys/bus/pci/devices/0000:01:00.0/iommu_group -> ../../kernel/iommu_groups/14 */
    group_fd = open("/dev/vfio/14", O_RDWR);

    /* 3. Group을 Container에 추가 */
    ioctl(group_fd, VFIO_GROUP_SET_CONTAINER, &container_fd);

    /* 4. IOMMU 타입 설정 (Type1 = Intel VT-d / AMD-Vi) */
    ioctl(container_fd, VFIO_SET_IOMMU, VFIO_TYPE1_IOMMU);

    /* 5. 장치 FD 가져오기 */
    device_fd = ioctl(group_fd, VFIO_GROUP_GET_DEVICE_FD, "0000:01:00.0");

    /* 6. DMA 매핑 — 호스트 가상 메모리를 IOVA(장치 주소)에 매핑 */
    struct vfio_iommu_type1_dma_map dma_map = {
        .argsz = sizeof(dma_map),
        .flags = VFIO_DMA_MAP_FLAG_READ | VFIO_DMA_MAP_FLAG_WRITE,
        .vaddr = (uint64_t)host_vaddr,   /* 호스트 가상 주소 */
        .iova  = 0x1000000,             /* 장치에서 보이는 주소 */
        .size  = dma_size,
    };
    ioctl(container_fd, VFIO_IOMMU_MAP_DMA, &dma_map);

    return device_fd;
}

보안 모델과 DMA 격리

VFIO의 핵심 보안 특성은 IOMMU를 통한 DMA 격리입니다. 디바이스가 DMA를 시도할 때 IOMMU가 IOVA를 물리 주소(Physical Address)로 변환하는 과정에서 허가되지 않은 메모리 영역 접근을 차단합니다.

DMA 공격 방지

# IOMMU가 올바르게 활성화됐는지 확인
dmesg | grep -E "IOMMU|DMAR|IOMMU enabled"
# [ 0.082] DMAR: IOMMU enabled
# [ 0.156] DMAR: Intel(R) Virtualization Technology for Directed I/O

# IOMMU 그룹별 장치 격리 확인
for d in /sys/bus/pci/devices/*; do
    echo "$(basename $d): $(readlink $d/iommu_group | sed 's/.*iommu_groups\///')"
done

# Kernel lockdown 모드에서 VFIO_NOIOMMU 금지 확인
cat /sys/module/vfio/parameters/enable_unsafe_noiommu_mode
# 0 (비활성) — 프로덕션 환경에서 반드시 0이어야 함

DMA Remapping

IOVA(I/O Virtual Address) 할당: VFIO Type1 백엔드는 사용자가 VFIO_IOMMU_MAP_DMA로 지정한 IOVA 주소를 IOMMU 페이지 테이블(Page Table)에 등록합니다. QEMU는 VM의 게스트 물리 주소(GPA)를 IOVA로 직접 사용하여 1:1 매핑을 구성하며, 이로써 게스트 디바이스 드라이버가 사용하는 DMA 주소가 IOMMU를 통해 올바른 호스트 물리 메모리(HPA)에 도달합니다.

IOTLB 무효화(Invalidation) 전략: DMA 매핑이 변경되면 IOMMU의 IOTLB(I/O Translation Lookaside Buffer)를 무효화해야 합니다. 무효화 범위가 클수록 오버헤드(Overhead)가 커집니다.

Nested Translation (2단계 변환): Intel VT-d의 Scalable Mode와 AMD-Vi의 Guest Translation에서 지원하는 기능으로, 게스트 IOMMU와 호스트 IOMMU가 동시에 동작합니다. 1단계(Stage-1)는 게스트 OS가 관리하는 GVA→GPA 변환이고, 2단계(Stage-2)는 호스트가 관리하는 GPA→HPA 변환입니다. 이를 통해 게스트 내에서 VFIO 중첩 가상화(nested VFIO)를 구현할 수 있습니다.

PASID (Process Address Space ID): PCIe PASID 확장을 사용하면 단일 장치 내에서 여러 프로세스(Process)의 주소 공간을 독립적으로 매핑할 수 있습니다. SR-IOV 없이도 프로세스별 격리를 제공하며, SVA(Shared Virtual Addressing)와 결합하여 CPU와 장치가 동일한 가상 주소(Virtual Address)를 사용합니다.

/* IOTLB 무효화 코드 경로 — drivers/iommu/intel/iommu.c */

/* Page-selective IOTLB 무효화 */
static void qi_flush_iotlb(struct intel_iommu *iommu,
                            u16 did, u64 addr,
                            unsigned int size_order, u64 type)
{
    struct qi_desc desc;

    desc.qw0 = QI_IOTLB_DID(did) | QI_IOTLB_GRAN(type)
             | QI_IOTLB_TYPE;
    desc.qw1 = QI_IOTLB_ADDR(addr) | QI_IOTLB_IH(ih)
             | QI_IOTLB_AM(size_order);

    /* Queued Invalidation — 비동기 무효화 큐 제출 */
    qi_submit_sync(iommu, &desc, 1, 0);
}

/* VFIO unmap 시 호출되는 IOTLB 무효화 */
/* vfio_iommu_type1.c → vfio_unmap_unpin() → iommu_unmap() */
/*   → intel_iommu_iotlb_sync_map() → qi_flush_iotlb() */

/* IOVA 할당자 — kernel/dma/iova.c */
struct iova *alloc_iova(struct iova_domain *iovad,
                        unsigned long size,
                        unsigned long limit_pfn,
                        bool size_aligned)
{
    /* Red-black tree 기반 IOVA 범위 할당 */
    /* VFIO는 사용자가 IOVA를 직접 지정하므로 */
    /* 이 함수 대신 rb_tree에 직접 삽입 */
    ...
}

VFIO_TYPE1_IOMMU 구현

VFIO_TYPE1_IOMMU는 x86 Intel VT-d 및 AMD-Vi IOMMU를 지원하는 가장 일반적인 VFIO 백엔드입니다. VFIO_TYPE1v2_IOMMU는 여기에 IOTLB 무효화 최적화와 pinned pages 지원을 추가합니다.

/* drivers/vfio/vfio_iommu_type1.c 핵심 자료구조 */

struct vfio_iommu {
    struct list_head    domain_list;  /* IOMMU 도메인 목록 */
    struct list_head    iova_list;    /* 유효한 IOVA 범위 */
    struct rb_root      dma_list;     /* DMA 매핑 트리 */
    bool                v2;           /* TYPE1v2 여부 */
};

struct vfio_dma {
    struct rb_node  node;
    dma_addr_t      iova;       /* 장치 주소 */
    unsigned long   vaddr;      /* 호스트 가상 주소 */
    size_t          size;
    int             prot;       /* IOMMU_READ | IOMMU_WRITE */
    bool            iommu_mapped;
};

/* VFIO_IOMMU_MAP_DMA ioctl 처리 */
static int vfio_dma_do_map(struct vfio_iommu *iommu,
                           struct vfio_iommu_type1_dma_map *map)
{
    /* 호스트 페이지 핀 (물리 주소 고정) */
    vfio_pin_pages_remote(dma, vaddr, npage, &pfn_base);

    /* IOMMU 도메인에 IOVA → 물리 주소 매핑 */
    iommu_map(domain->domain, iova, pfn_to_phys(pfn), size, prot);
    return 0;
}

mdev (Mediated Device) 프레임워크

mdev는 하나의 물리 장치를 여러 가상 장치(mdev 인스턴스)로 분할하는 소프트웨어 프레임워크입니다. SR-IOV가 있는 하드웨어에서는 VF를 mdev에 노출하고, 없는 경우(구형 GPU)에는 소프트웨어로 에뮬레이션합니다.

mdev 드라이버 구현

#include <linux/mdev.h>

/* mdev 부모 장치 오퍼레이션 — 물리 GPU 드라이버가 구현 */
static const struct mdev_parent_ops my_gpu_mdev_ops = {
    .owner           = THIS_MODULE,
    .device_driver   = &my_gpu_mdev_driver,

    /* mdev 인스턴스 생성/삭제 */
    .create          = my_gpu_mdev_create,
    .remove          = my_gpu_mdev_remove,

    /* 지원하는 mdev 유형 목록 */
    .supported_type_groups = my_gpu_mdev_types,

    /* sysfs 인터페이스 */
    .mdev_attr_groups = my_gpu_mdev_dev_attrs,
};

/* mdev 유형 정의 (예: 1/4, 1/2 GPU) */
static struct attribute *my_gpu_1q_attrs[] = {
    &dev_attr_available_instances.attr,   /* 최대 4개 */
    &dev_attr_device_api.attr,            /* "vfio-pci" */
    &dev_attr_name.attr,                  /* "GPU-1/4" */
    NULL,
};

/* 인스턴스 생성 — VM당 1개의 mdev 인스턴스 */
static int my_gpu_mdev_create(struct mdev_device *mdev)
{
    struct my_vgpu *vgpu;

    vgpu = kzalloc(sizeof(*vgpu), GFP_KERNEL);
    my_gpu_partition_hw(vgpu);   /* GPU 자원(VRAM, SM) 분할 */
    mdev_set_drvdata(mdev, vgpu);
    return 0;
}

mdev sysfs 관리

# mdev 유형 확인 (GPU가 지원하는 분할 방식)
ls /sys/bus/pci/devices/0000:01:00.0/mdev_supported_types/
# nvidia-35 — Tesla M10-8Q (8GB per VM, max 2 instances)
# nvidia-36 — Tesla M10-4Q (4GB per VM, max 4 instances)

# mdev 인스턴스 생성
UUID=$(uuidgen)
echo $UUID > /sys/bus/pci/devices/0000:01:00.0/mdev_supported_types/nvidia-36/create

# 생성된 mdev 확인
ls /sys/bus/mdev/devices/  # $UUID 디렉토리
mdevctl list               # 활성 mdev 목록

# QEMU에 mdev 추가
## -device vfio-pci,sysfsdev=/sys/bus/mdev/devices/$UUID

KVM 통합과 QEMU 설정

QEMU는 VFIO를 통해 물리 PCI 장치를 VM에 직접 노출합니다. KVM 하이퍼바이저(Hypervisor)와 결합하면 CPU 에뮬레이션 오버헤드 없이 하드웨어를 직접 제어할 수 있습니다.

# vfio-pci 드라이버 바인딩 (기존 드라이버 언바인딩)
# 방법 1: modprobe 시 바인딩
modprobe vfio-pci ids=10de:2684,10de:22ba

# 방법 2: 수동 바인딩 스크립트
DEVICE=0000:01:00.0
VENDOR=$(cat /sys/bus/pci/devices/$DEVICE/vendor)
DEVID=$(cat /sys/bus/pci/devices/$DEVICE/device)

# 기존 드라이버 언바인딩
echo $DEVICE > /sys/bus/pci/devices/$DEVICE/driver/unbind

# vfio-pci 드라이버 바인딩
echo $VENDOR $DEVID > /sys/bus/pci/drivers/vfio-pci/new_id

# QEMU VM 실행 — GPU passthrough
qemu-system-x86_64 \
  -enable-kvm \
  -cpu host \
  -m 32G \
  -smp 16 \
  -device vfio-pci,host=01:00.0,multifunction=on,x-vga=on \
  -device vfio-pci,host=01:00.1 \
  -drive file=windows.qcow2,if=virtio \
  -vga none \
  -nographic

KVM 메모리 매핑

KVM은 VM의 게스트 물리 주소(GPA)를 VFIO Container에 등록합니다. QEMU의 memory_listener가 GPA → HPA 매핑을 VFIO DMA 맵으로 변환합니다.

QEMU vfio_listener_region_add() 내부 흐름:

1. KVM_SET_USER_MEMORY_REGION으로 KVM EPT/NPT를 설정합니다
2. VFIO_IOMMU_MAP_DMA로 IOMMU 매핑을 추가합니다

이를 통해 GPU DMA가 게스트 물리 주소를 사용해 VM 메모리에 직접 접근할 수 있습니다.

VFIO 라이브 마이그레이션

VFIO v2 마이그레이션 프로토콜은 커널 6.2에서 도입되었으며, 장치 상태를 file descriptor 기반의 스트리밍 인터페이스로 전송합니다. 이전 v1 프로토콜은 구조체(Struct) 기반이었으나 유연성 부족으로 폐기되었습니다.

Pre-copy / Stop-copy 프로토콜:

• Pre-copy 단계: 장치가 계속 동작하면서 변경된 상태를 점진적으로 전송합니다. VRAM이 큰 GPU의 경우 수 GB의 상태를 전송해야 하므로, 이 단계에서 대부분의 데이터를 미리 전송하여 최종 stop-copy 단계의 다운타임을 최소화합니다.
• Stop-copy 단계: 장치를 정지시키고 마지막으로 변경된 상태만 전송합니다. 이 단계에서의 데이터 크기가 VM 다운타임을 결정합니다.
• Dirty page tracking: VFIO_IOMMU_DIRTY_PAGES ioctl로 장치가 DMA로 변경한 호스트 페이지를 추적합니다. 이 정보는 KVM의 dirty page bitmap과 합쳐져 라이브 마이그레이션의 메모리 수렴 판단에 사용됩니다.

/* VFIO v2 마이그레이션 상태 전이 — VFIO_DEVICE_FEATURE ioctl */
#include <linux/vfio.h>

int vfio_migrate_start_precopy(int device_fd)
{
    struct vfio_device_feature *feature;
    struct vfio_device_feature_mig_state *mig;
    size_t alloc_size;
    int ret;

    alloc_size = sizeof(*feature) + sizeof(*mig);
    feature = calloc(1, alloc_size);
    feature->argsz = alloc_size;
    feature->flags = VFIO_DEVICE_FEATURE_SET
                   | VFIO_DEVICE_FEATURE_MIG_DEVICE_STATE;

    mig = (struct vfio_device_feature_mig_state *)feature->data;

    /* 1단계: PRE_COPY 상태로 전이 (장치 계속 동작) */
    mig->device_state = VFIO_DEVICE_STATE_PRE_COPY;
    ret = ioctl(device_fd, VFIO_DEVICE_FEATURE, feature);
    if (ret < 0) return ret;

    /* migration_fd를 통해 상태 스트리밍 읽기 */
    int migration_fd = mig->data_fd;
    /* read(migration_fd, buf, size) 반복 → 대상 호스트 전송 */

    /* 2단계: STOP_COPY 상태로 전이 (장치 정지) */
    mig->device_state = VFIO_DEVICE_STATE_STOP_COPY;
    ret = ioctl(device_fd, VFIO_DEVICE_FEATURE, feature);
    /* 마지막 변경분 read(migration_fd, ...) */

    close(migration_fd);
    free(feature);
    return 0;
}

/* 대상 호스트에서 장치 상태 복원 */
int vfio_migrate_resume(int device_fd, const void *state_data,
                        size_t state_size)
{
    struct vfio_device_feature *feature;
    struct vfio_device_feature_mig_state *mig;

    /* ... feature 할당 (위와 동일) ... */

    /* 1단계: RESUMING 상태로 전이 */
    mig->device_state = VFIO_DEVICE_STATE_RESUMING;
    ioctl(device_fd, VFIO_DEVICE_FEATURE, feature);

    int migration_fd = mig->data_fd;

    /* 상태 데이터를 migration_fd에 기록 */
    write(migration_fd, state_data, state_size);
    close(migration_fd);

    /* 2단계: RUNNING 상태로 전이 (장치 재개) */
    mig->device_state = VFIO_DEVICE_STATE_RUNNING;
    ioctl(device_fd, VFIO_DEVICE_FEATURE, feature);

    free(feature);
    return 0;
}

/* Dirty page tracking */
struct vfio_iommu_type1_dirty_bitmap dirty = {
    .argsz = sizeof(dirty),
    .flags = VFIO_IOMMU_DIRTY_PAGES_FLAG_GET_BITMAP,
};
struct vfio_iommu_type1_dirty_bitmap_get range = {
    .iova   = 0x1000000,
    .size   = dma_size,
    .bitmap = {
        .pgsize = 4096,
        .size   = bitmap_size,
        .data   = bitmap_ptr,
    },
};
/* ioctl(container_fd, VFIO_IOMMU_DIRTY_PAGES, &dirty) */
/* bitmap_ptr에 dirty 페이지 비트맵 반환 */

vfio-user 프로토콜: vfio-user는 VFIO 장치를 UNIX 도메인 소켓(Socket)을 통해 원격 프로세스에 노출하는 프로토콜입니다. QEMU와 장치 에뮬레이터가 별도 프로세스에서 동작할 수 있어 보안 격리와 장애 격리를 강화합니다. SPDK의 NVMe 에뮬레이터가 이 방식을 사용합니다.

GPU Passthrough 실용 설정

시스템 요구사항

# CPU IOMMU 지원 확인
grep -E "vmx|svm" /proc/cpuinfo | head -1
# vmx — Intel VT-x (VT-d도 함께 필요)
# svm — AMD-V (AMD-Vi도 함께 필요)

# 커널 부트 파라미터 설정 (/etc/default/grub)
# Intel: GRUB_CMDLINE_LINUX="intel_iommu=on iommu=pt"
# AMD:   GRUB_CMDLINE_LINUX="amd_iommu=on iommu=pt"
# iommu=pt: Passthrough 모드 — 비-패스스루 장치 성능 보호

update-grub && reboot

# 재부팅 후 IOMMU 활성화 확인
dmesg | grep -E "IOMMU|DMAR" | head -5

AMD GPU passthrough (ROCm)

# AMD GPU passthrough — reset 버그 없음, 오픈소스 드라이버
# 1. vfio-pci 바인딩
echo "0000:03:00.0" > /sys/bus/pci/devices/0000:03:00.0/driver/unbind
echo "1002 744c" > /sys/bus/pci/drivers/vfio-pci/new_id  # RX 7900 XTX

# 2. QEMU AMD GPU passthrough (ROCm 가능)
qemu-system-x86_64 \
  -enable-kvm \
  -cpu host \
  -device vfio-pci,host=03:00.0,multifunction=on \
  -device vfio-pci,host=03:00.1 \
  ...

# 3. VM 내 ROCm 설치 후 GPU 확인
rocm-smi  # 패스스루된 GPU 직접 접근
rocminfo  # 컴퓨팅 큐 확인

NVIDIA GPU passthrough 고급 설정

NVIDIA GPU는 패스스루 시 몇 가지 추가 작업이 필요합니다. 특히 vBIOS 추출/패칭, Code 43 에러 회피, ACS override가 빈번하게 요구됩니다.

# NVIDIA vBIOS 추출 (GPU ROM 덤프)
# 일부 GPU는 UEFI vBIOS를 QEMU에 전달해야 정상 부팅
echo 1 > /sys/bus/pci/devices/0000:01:00.0/rom
cat /sys/bus/pci/devices/0000:01:00.0/rom > gpu_vbios.rom
echo 0 > /sys/bus/pci/devices/0000:01:00.0/rom

# QEMU에 vBIOS 전달
# -device vfio-pci,host=01:00.0,romfile=gpu_vbios.rom

# NVIDIA Code 43 우회 (Windows VM에서 드라이버 거부 방지)
# QEMU에서 하이퍼바이저 정보 숨기기
# -cpu host,kvm=off,hv_vendor_id=randomid
# 또는 libvirt XML에서:
# <hyperv><vendor_id state='on' value='randomid'/></hyperv>
# <kvm><hidden state='on'/></kvm>

# ACS override 패치 적용 확인 (보안 위험)
# 커널 파라미터에 pcie_acs_override=downstream,multifunction 추가
dmesg | grep -i "acs override"
# 패치가 적용되면 각 장치가 독립 IOMMU 그룹으로 분리됨

# GPU FLR(Function Level Reset) 지원 확인
lspci -vvv -s 01:00.0 | grep -E "FLR|Reset"
# Capabilities: [xxx] ... FLReset+
# AMD GPU는 FLR 지원이 우수 (리셋 버그 거의 없음)
# NVIDIA GPU는 일부 모델에서 FLR 후 행(hang) 발생 가능

# GPU 패스스루 종합 문제해결 스크립트
#!/bin/bash

echo "=== IOMMU 상태 ==="
dmesg | grep -E "DMAR|IOMMU" | head -5

echo "=== VFIO 모듈 ==="
lsmod | grep vfio

echo "=== GPU IOMMU 그룹 ==="
GPU_BDF="0000:01:00.0"
IOMMU_GRP=$(readlink /sys/bus/pci/devices/$GPU_BDF/iommu_group | sed 's/.*iommu_groups\///')
echo "GPU $GPU_BDF → IOMMU Group $IOMMU_GRP"
ls /sys/kernel/iommu_groups/$IOMMU_GRP/devices/

echo "=== 드라이버 바인딩 상태 ==="
for dev in /sys/kernel/iommu_groups/$IOMMU_GRP/devices/*; do
    BDF=$(basename $dev)
    DRV=$(readlink /sys/bus/pci/devices/$BDF/driver 2>/dev/null | xargs basename 2>/dev/null)
    echo "  $BDF: driver=${DRV:-none}"
done

echo "=== FLR / Reset 지원 ==="
lspci -vvv -s ${GPU_BDF} | grep -E "FLR|Reset"

echo "=== VFIO dmesg 로그 ==="
dmesg | grep -i vfio | tail -10

VFIO-PCI 드라이버 내부 구조

vfio-pci 모듈 구조: drivers/vfio/pci/ 디렉토리에 위치하며, vfio_pci_core가 공통 로직을, vfio_pci가 실제 PCI 드라이버 등록(Driver Registration)을 담당합니다. 벤더별 VFIO 변형(mlx5_vfio_pci, hisi_acc_vfio_pci 등)은 vfio_pci_core를 기반으로 마이그레이션이나 특수 기능을 추가합니다.

/* drivers/vfio/pci/vfio_pci_core.c — 핵심 구조체 */

struct vfio_pci_core_device {
    struct vfio_device    vdev;          /* VFIO 장치 기본 */
    struct pci_dev       *pdev;          /* PCI 장치 */
    struct mutex         igate;          /* 인터럽트 게이트 */

    /* BAR 영역 정보 */
    struct vfio_pci_region *region;       /* BAR0-5, ROM, Config */
    u32                  num_regions;

    /* 인터럽트 상태 */
    struct vfio_pci_irq_ctx *ctx;         /* eventfd 컨텍스트 */
    int                  num_ctx;
    int                  irq_type;       /* INTX/MSI/MSI-X */

    /* Config space 가상화 */
    u8                   *vconfig;       /* 가상화된 config 값 */
    u8                   *pci_config_map; /* 레지스터별 권한 */

    /* 리셋 관련 */
    bool                 has_flr;
    bool                 has_pm_reset;
    bool                 needs_reset;
};

/* BAR mmap 구현 */
static int vfio_pci_mmap(struct vfio_device *core_vdev,
                         struct vm_area_struct *vma)
{
    /* vm_pgoff에서 region index와 offset 디코딩 */
    unsigned int index = vma->vm_pgoff >> (VFIO_PCI_OFFSET_SHIFT - PAGE_SHIFT);

    /* MMIO BAR만 mmap 허용 (I/O port BAR 불가) */
    if (!(vdev->bar_mmap_supported & (1 << index)))
        return -EINVAL;

    /* 물리 BAR 주소를 유저스페이스에 매핑 */
    return io_remap_pfn_range(vma, vma->vm_start, phys >> PAGE_SHIFT,
                              req_len, vma->vm_page_prot);
}

FLR / Bus Reset / PM Reset 우선순위(Priority): VFIO_DEVICE_RESET ioctl은 다음 순서로 리셋을 시도합니다.

1. FLR (Function Level Reset): PCIe Capability의 FLR 비트를 사용. 가장 정밀한 리셋으로 해당 Function만 리셋합니다.
2. PM Reset (D3hot → D0): PCI Power Management을 이용한 리셋. 일부 장치에서 불완전할 수 있습니다.
3. Bus Reset (Secondary Bus Reset): 해당 버스(Bus) 아래 모든 장치를 리셋합니다. 같은 IOMMU 그룹 내 다른 장치에 영향을 줄 수 있어 마지막 수단입니다.

/* vfio_pci_core_ioctl() — VFIO_DEVICE_RESET 처리 */
static int vfio_pci_core_ioctl_reset(struct vfio_pci_core_device *vdev)
{
    int ret;

    /* 1. FLR 시도 */
    if (vdev->has_flr) {
        ret = pci_reset_function(vdev->pdev);
        if (!ret) goto post_reset;
    }

    /* 2. PM Reset 시도 */
    if (vdev->has_pm_reset) {
        ret = pci_pm_reset(vdev->pdev, PCI_RESET_DO_RESET);
        if (!ret) goto post_reset;
    }

    /* 3. Bus Reset (같은 그룹 모든 장치 영향) */
    ret = pci_reset_bus(vdev->pdev);

post_reset:
    /* Config space 재초기화 */
    vfio_pci_set_power_state(vdev, PCI_D0);
    vfio_pci_init_config(vdev);
    return ret;
}

Interrupt Remapping (인터럽트 리매핑)

MSI/MSI-X 가상화: VFIO는 패스스루된 장치의 MSI/MSI-X 인터럽트를 KVM eventfd를 통해 VM에 전달합니다. 장치가 MSI 주소(0xFEExxxxx)에 쓰기를 하면, IOMMU의 Interrupt Remapping 테이블이 이를 적절한 CPU/벡터로 리매핑합니다.

/* VFIO MSI-X 인터럽트 설정 — eventfd 기반 */
#include <linux/vfio.h>
#include <sys/eventfd.h>

int setup_msix_interrupt(int device_fd, int vector_count)
{
    struct vfio_irq_set *irq_set;
    int32_t *fds;
    size_t alloc_size;

    alloc_size = sizeof(*irq_set) + vector_count * sizeof(int32_t);
    irq_set = calloc(1, alloc_size);

    irq_set->argsz = alloc_size;
    irq_set->flags = VFIO_IRQ_SET_DATA_EVENTFD
                   | VFIO_IRQ_SET_ACTION_TRIGGER;
    irq_set->index = VFIO_PCI_MSIX_IRQ_INDEX;
    irq_set->start = 0;
    irq_set->count = vector_count;

    fds = (int32_t *)irq_set->data;
    for (int i = 0; i < vector_count; i++)
        fds[i] = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);

    /* MSI-X 인터럽트 활성화 */
    ioctl(device_fd, VFIO_DEVICE_SET_IRQS, irq_set);

    /* 각 eventfd를 epoll/poll로 감시 */
    /* → KVM irqfd로 연결하면 VM-Exit 없이 인터럽트 전달 */
    free(irq_set);
    return 0;
}

/* KVM irqfd — eventfd → 게스트 인터럽트 직접 주입 */
struct kvm_irqfd irqfd = {
    .fd    = msix_eventfd,     /* VFIO MSI-X eventfd */
    .gsi   = guest_gsi,        /* 게스트 GSI 번호 */
    .flags = 0,
};
ioctl(kvm_vm_fd, KVM_IRQFD, &irqfd);

/* 결과: 장치 인터럽트 → eventfd → KVM → vLAPIC → vCPU */
/* Posted Interrupt 활성 시: 장치 → IOMMU → PID → vCPU (VM-Exit 없음) */

/* Posted Interrupt 활성화 조건: */
/* 1. CPU: Intel VT-x + APICv 또는 AMD-V + AVIC */
/* 2. IOMMU: VT-d IR + PI 또는 AMD-Vi GALOG */
/* 3. KVM: kvm_intel.enable_apicv=1 (기본값) */
/* 4. 장치: MSI/MSI-X 인터럽트 사용 */

진단 및 디버깅(Debugging)

# VFIO 로드 상태 확인
lsmod | grep vfio
# vfio_pci, vfio_pci_core, vfio_iommu_type1, vfio

# 장치가 vfio-pci에 바인딩됐는지 확인
lspci -nnk -d 10de:2684
# Kernel driver in use: vfio-pci  ← 성공
# Kernel driver in use: nvidia    ← 아직 바인딩 안 됨

# IOMMU 그룹 상태
ls /sys/kernel/iommu_groups/14/devices/
cat /sys/kernel/iommu_groups/14/type  # DMAv42 또는 identity

# VFIO 이벤트 dmesg 확인
dmesg | grep -i vfio | tail -20

# mdevctl로 mdev 상태 확인
mdevctl list --defined   # 정의된 인스턴스
mdevctl list             # 활성 인스턴스

mdev 드라이버 스택

커널 소스 가이드

커널 설정

# VFIO 핵심
CONFIG_VFIO=y                       # VFIO 코어
CONFIG_VFIO_PCI=y                   # vfio-pci 드라이버
CONFIG_VFIO_PCI_VGA=y               # VGA 장치 패스스루 (GPU)
CONFIG_VFIO_IOMMU_TYPE1=y           # x86 IOMMU 백엔드
CONFIG_VFIO_MDEV=y                  # mdev 코어
CONFIG_VFIO_MDEV_DEVICE=y           # mdev VFIO 장치

# IOMMU (선택)
CONFIG_INTEL_IOMMU=y                # Intel VT-d
CONFIG_AMD_IOMMU=y                  # AMD-Vi
CONFIG_IOMMU_SUPPORT=y
CONFIG_PCI_ACS=y                    # PCIe ACS 지원 (그룹 분리)
CONFIG_PCI_PASID=y                  # Process Address Space ID

# KVM 통합
CONFIG_KVM=y
CONFIG_KVM_VFIO=y                   # KVM ↔ VFIO 통합

VFIO 사용자 공간(User Space) API

VFIO는 사용자 공간에서 PCI 디바이스를 직접 제어할 수 있도록 /dev/vfio/를 통한 ioctl 기반 API를 제공합니다. Container → Group → Device 순서로 열어야 하며, 순서를 지키지 않으면 EINVAL이 반환됩니다.

디바이스 열기 전체 흐름

/* VFIO 디바이스 열기 — 전체 ioctl 시퀀스 */
#include <linux/vfio.h>

/* 1. Container 열기 — IOMMU 도메인의 기반 */
int container_fd = open("/dev/vfio/vfio", O_RDWR);

/* 2. IOMMU API 버전 확인 */
ioctl(container_fd, VFIO_GET_API_VERSION);  /* 반환: VFIO_API_VERSION */

/* 3. IOMMU 타입 확인 (TYPE1 = x86 VT-d/AMD-Vi) */
ioctl(container_fd, VFIO_CHECK_EXTENSION, VFIO_TYPE1v2_IOMMU);

/* 4. Group 열기 (IOMMU 그룹 번호) */
int group_fd = open("/dev/vfio/14", O_RDWR);

/* 5. Group → Container 연결 */
ioctl(group_fd, VFIO_GROUP_SET_CONTAINER, &container_fd);

/* 6. IOMMU 모델 설정 */
ioctl(container_fd, VFIO_SET_IOMMU, VFIO_TYPE1v2_IOMMU);

/* 7. Device FD 획득 (BDF 문자열) */
int device_fd = ioctl(group_fd, VFIO_GROUP_GET_DEVICE_FD,
                       "0000:01:00.0");

/* 8. 디바이스 정보 조회 */
struct vfio_device_info dev_info = { .argsz = sizeof(dev_info) };
ioctl(device_fd, VFIO_DEVICE_GET_INFO, &dev_info);
/* dev_info.num_regions: BAR 수, dev_info.num_irqs: IRQ 수 */

DMA 매핑(Mapping) 설정

/* 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)guest_memory,     /* 호스트 가상 주소 */
    .iova  = 0x0,                     /* IOMMU 가상 주소 (GPA) */
    .size  = guest_ram_size,          /* 매핑 크기 */
};
ioctl(container_fd, VFIO_IOMMU_MAP_DMA, &dma_map);

/* 해제 */
struct vfio_iommu_type1_dma_unmap dma_unmap = {
    .argsz = sizeof(dma_unmap),
    .iova  = 0x0,
    .size  = guest_ram_size,
};
ioctl(container_fd, VFIO_IOMMU_UNMAP_DMA, &dma_unmap);

인터럽트(Interrupt) 설정

/* MSI-X 인터럽트 설정 — eventfd 기반 */
int eventfd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);

struct {
    struct vfio_irq_set hdr;
    int fd;
} irq_set = {
    .hdr.argsz = sizeof(irq_set),
    .hdr.flags = VFIO_IRQ_SET_DATA_EVENTFD | VFIO_IRQ_SET_ACTION_TRIGGER,
    .hdr.index = VFIO_PCI_MSIX_IRQ_INDEX,
    .hdr.start = 0,
    .hdr.count = 1,
    .fd = eventfd,
};
ioctl(device_fd, VFIO_DEVICE_SET_IRQS, &irq_set);

/* epoll로 인터럽트 대기 */
struct epoll_event ev = { .events = EPOLLIN, .data.fd = eventfd };
epoll_ctl(epoll_fd, EPOLL_CTL_ADD, eventfd, &ev);
epoll_wait(epoll_fd, events, 1, -1);  /* 인터럽트 수신 */

GPU 가상화(Virtualization) 기술 비교

GPU 가상화는 벤더마다 다른 접근 방식을 사용합니다. SR-IOV 기반, mdev 기반, 펌웨어 기반 등 다양한 방식의 특징과 한계를 비교합니다.

NVIDIA vGPU 아키텍처

NVIDIA vGPU는 호스트의 독점 nvidia-vgpu-mgr 데몬과 커널 모듈(nvidia.ko)이 mdev 인터페이스를 통해 GPU 리소스를 분할합니다.

# NVIDIA vGPU 설정 절차

# 1. 지원되는 vGPU 프로파일 확인
ls /sys/bus/pci/devices/0000:41:00.0/mdev_supported_types/
# nvidia-256  nvidia-257  nvidia-258  ...

# 2. 프로파일별 상세 정보
cat /sys/bus/pci/devices/0000:41:00.0/mdev_supported_types/nvidia-256/description
# GRID A100-4C  (4GB VRAM, max 1 display, compute only)

# 3. vGPU 인스턴스 생성
echo "b3a2f5e0-0001-0001-0001-000000000001" > \
    /sys/bus/pci/devices/0000:41:00.0/mdev_supported_types/nvidia-256/create

# 4. mdevctl로 영구 등록 (리부트 후에도 유지)
mdevctl define --auto --uuid b3a2f5e0-0001-0001-0001-000000000001

# 5. QEMU에서 사용
qemu-system-x86_64 \
    -device vfio-pci,sysfsdev=/sys/bus/mdev/devices/b3a2f5e0-...,display=off \
    ...

Intel GVT-g (Graphics Virtualization Technology)

# Intel GVT-g 설정 (오픈소스 — i915 드라이버 기반)

# 커널 파라미터
# i915.enable_gvt=1 intel_iommu=on

# 지원 타입 확인
ls /sys/bus/pci/devices/0000:00:02.0/mdev_supported_types/
# i915-GVTg_V5_4  i915-GVTg_V5_8

# 4GB VRAM / 1 디스플레이 인스턴스 생성
echo "$(uuidgen)" > \
    /sys/bus/pci/devices/0000:00:02.0/mdev_supported_types/i915-GVTg_V5_4/create

# GVT-g 한계:
# - 최신 GPU(12세대+)에서는 SR-IOV로 전환됨
# - OpenGL/Vulkan 제한적 지원 (일부 API 미동작)
# - 성능 오버헤드: ~10-15%

VFIO v2 마이그레이션(Migration) 프로토콜

VFIO 라이브 마이그레이션(Live Migration)은 디바이스의 내부 상태를 직렬화하여 소스 호스트에서 대상 호스트로 전송하는 기능입니다. v2 마이그레이션 API(커널 5.18+)는 상태 머신(State Machine) 기반으로 설계되었습니다.

마이그레이션 상태 머신

/* VFIO v2 마이그레이션 — 소스 호스트 절차 */

/* 1. Pre-copy 시작 (VM 계속 실행) */
ioctl(device_fd, VFIO_DEVICE_FEATURE,
      &(struct vfio_device_feature) {
          .flags = VFIO_DEVICE_FEATURE_MIG_DEVICE_STATE | VFIO_DEVICE_FEATURE_SET,
          .data = VFIO_DEVICE_STATE_PRE_COPY,
      });

/* 2. Pre-copy 데이터 읽기 (반복) */
int mig_fd = ioctl(device_fd, VFIO_MIG_GET_DATA_FD);
while ((ssize_t n = read(mig_fd, buf, sizeof(buf))) > 0)
    send_to_destination(buf, n);
close(mig_fd);

/* 3. Stop-and-copy (VM 정지) */
ioctl(device_fd, VFIO_DEVICE_FEATURE,
      &(struct vfio_device_feature) {
          .data = VFIO_DEVICE_STATE_STOP_COPY,
      });

/* 4. 최종 상태 전송 */
mig_fd = ioctl(device_fd, VFIO_MIG_GET_DATA_FD);
while ((n = read(mig_fd, buf, sizeof(buf))) > 0)
    send_to_destination(buf, n);

IOMMU 중첩(Nested) 변환

중첩 IOMMU(Nested IOMMU)는 게스트 OS가 자체 IOMMU(vIOMMU)를 가질 때, 호스트 IOMMU와 2단계 주소 변환을 수행하는 기술입니다. Intel VT-d의 scalable mode(first-level/second-level), AMD-Vi의 GVA→GPA→HPA 변환이 대표적입니다.

2단계 변환 구조

게스트 DMA 요청 (GVA/GIOVA)
    │
    ▼
┌──────────────────────┐
│  1단계: vIOMMU       │  게스트 OS가 관리 (Stage-1 / First-level)
│  GIOVA → GPA         │  게스트 페이지 테이블
└──────────┬───────────┘
           │
           ▼
┌──────────────────────┐
│  2단계: 호스트 IOMMU  │  하이퍼바이저가 관리 (Stage-2 / Second-level)
│  GPA → HPA           │  EPT/NPT와 유사
└──────────┬───────────┘
           │
           ▼
       물리 메모리 (HPA)

PASID (Process Address Space ID)

PASID는 단일 디바이스 내에서 프로세스별 주소 공간을 분리하는 20비트(Bit) 식별자입니다. SVA(Shared Virtual Addressing)와 결합하면 디바이스가 프로세스의 가상 주소를 직접 사용할 수 있습니다.

/* PASID를 이용한 SVA 바인딩 */
#include <linux/iommu.h>

/* 디바이스에 PASID 할당 */
struct iommu_sva *sva = iommu_sva_bind_device(dev, current->mm);
u32 pasid = iommu_sva_get_pasid(sva);

/*
 * 이제 디바이스는 PASID를 TLP 프리픽스에 포함하여 DMA 요청을 보냄
 * IOMMU는 PASID로 올바른 페이지 테이블을 선택
 * → 프로세스 A의 가상 주소로 DMA 가능
 *
 * 페이지 폴트 발생 시: IOMMU가 PRQ(Page Request Queue)로
 * 커널에 알리고, 커널이 페이지를 할당한 후 응답
 */

/* 해제 */
iommu_sva_unbind_device(sva);

VFIO 보안(Security)

VFIO의 보안 모델은 IOMMU 격리에 의존합니다. 격리가 불완전하면 악의적 VM이 호스트 메모리를 읽거나 수정할 수 있으므로, 다음 보안 요구사항을 반드시 확인해야 합니다.

ACS (Access Control Services) 확인

# PCIe ACS 지원 여부 확인
lspci -vvs 01:00.0 | grep -i "Access Control"
# Capabilities: [100] Access Control Services
#   ACSCap: SrcValid+ TransBlk+ ReqRedir+ CmpltRedir+ UpstreamFwd+ EgressCtrl+
#   ACSCtl: SrcValid+ TransBlk+ ReqRedir+ CmpltRedir+ UpstreamFwd- EgressCtrl-

# ACS 미지원 시: 같은 PCIe 스위치 하위 디바이스가 같은 IOMMU 그룹
# → 개별 패스스루 불가 (보안 경계 위반)

# ACS override 패치 (보안 위험 — 개발용만)
# 커널 파라미터: pcie_acs_override=downstream,multifunction

보안 체크리스트

QEMU/libvirt 연동

실제 가상화 환경에서 VFIO 패스스루를 설정하는 상세 절차와 주의사항을 설명합니다.

QEMU 명령행 설정

# GPU 패스스루 전체 QEMU 명령
qemu-system-x86_64 \
    -enable-kvm \
    -m 16G \
    -cpu host \
    -smp 8 \
    # VFIO GPU 패스스루
    -device vfio-pci,host=01:00.0,multifunction=on,x-vga=on \
    -device vfio-pci,host=01:00.1 \   # GPU HDMI 오디오
    # UEFI 펌웨어 (OVMF)
    -drive if=pflash,format=raw,readonly=on,file=/usr/share/OVMF/OVMF_CODE.fd \
    -drive if=pflash,format=raw,file=OVMF_VARS.fd \
    # Hugepage 메모리 (성능 최적화)
    -mem-path /dev/hugepages \
    -mem-prealloc \
    # vCPU 핀닝 (NUMA 정렬)
    -object memory-backend-memfd,id=mem0,size=16G,hugetlb=on \
    -numa node,memdev=mem0,cpus=0-7 \
    # 디스크
    -drive file=vm.qcow2,if=virtio \
    # 네트워크
    -netdev user,id=net0 -device virtio-net-pci,netdev=net0

libvirt XML 설정

<!-- /etc/libvirt/qemu/gpu-vm.xml -->
<domain type='kvm'>
  <name>gpu-vm</name>
  <memory unit='GiB'>16</memory>
  <vcpu placement='static'>8</vcpu>

  <!-- CPU 핀닝 -->
  <cputune>
    <vcpupin vcpu='0' cpuset='0'/>
    <vcpupin vcpu='1' cpuset='1'/>
    <!-- ... -->
  </cputune>

  <!-- Hugepage 메모리 -->
  <memoryBacking>
    <hugepages/>
    <locked/>
  </memoryBacking>

  <devices>
    <!-- GPU 패스스루 -->
    <hostdev mode='subsystem' type='pci' managed='yes'>
      <source>
        <address domain='0x0000' bus='0x01'
                 slot='0x00' function='0x0'/>
      </source>
      <rom bar='on'/>
    </hostdev>

    <!-- mdev vGPU 할당 -->
    <hostdev mode='subsystem' type='mdev'
             model='vfio-pci' managed='no'>
      <source>
        <address uuid='b3a2f5e0-0001-0001-0001-000000000001'/>
      </source>
    </hostdev>
  </devices>
</domain>

패스스루 트러블슈팅

네트워크 디바이스 가상화

네트워크 디바이스의 VFIO 패스스루는 GPU와 다른 패턴을 따릅니다. SR-IOV VF(Virtual Function)를 활용한 고성능 네트워크 가상화가 가장 일반적입니다.

SR-IOV VF 생성 및 패스스루

# SR-IOV VF 생성 (Intel 82599, Mellanox ConnectX)

# 1. 현재 VF 수 확인
cat /sys/class/net/ens1f0/device/sriov_totalvfs
# 63

# 2. VF 4개 생성
echo 4 > /sys/class/net/ens1f0/device/sriov_numvfs

# 3. VF MAC 주소 설정 (PF에서)
ip link set ens1f0 vf 0 mac 52:54:00:aa:bb:01
ip link set ens1f0 vf 1 mac 52:54:00:aa:bb:02
ip link set ens1f0 vf 2 mac 52:54:00:aa:bb:03
ip link set ens1f0 vf 3 mac 52:54:00:aa:bb:04

# 4. VF VLAN 설정 (선택)
ip link set ens1f0 vf 0 vlan 100

# 5. VF를 vfio-pci에 바인딩
VF_BDF=$(readlink /sys/class/net/ens1f0/device/virtfn0 | sed 's|../||')
echo $VF_BDF > /sys/bus/pci/devices/$VF_BDF/driver/unbind
echo "vfio-pci" > /sys/bus/pci/devices/$VF_BDF/driver_override
echo $VF_BDF > /sys/bus/pci/drivers/vfio-pci/bind

# 6. QEMU에서 VF 패스스루
qemu-system-x86_64 \
    -device vfio-pci,host=$VF_BDF \
    ...

참고 링크

커널 문서

• VFIO — Virtual Function I/O — VFIO 프레임워크의 공식 커널 문서입니다
• VFIO Mediated Devices — mdev(Mediated Device) 프레임워크의 공식 커널 문서입니다
• IOMMU User API — IOMMU 사용자 공간 API에 대한 공식 문서입니다
• PCI Passthrough via VFIO — VFIO를 통한 PCI 장치 패스스루 드라이버 수용 정책입니다

LWN 기사

• LWN: VFIO — VFIO 프레임워크의 설계 배경과 초기 구현을 다루는 기사입니다
• LWN: Mediated devices — mdev 프레임워크의 도입 배경과 설계 원리를 설명합니다
• LWN: Safe device assignment with VFIO — VFIO를 사용한 안전한 장치 할당 메커니즘을 분석합니다
• LWN: GPU passthrough, mediated devices, and VFIO — GPU 패스스루와 mdev 기반 가상화를 심층적으로 다룹니다
• LWN: IOMMU groups — IOMMU 그룹 개념과 장치 격리 단위를 설명합니다
• LWN: Scalable VFIO — 대규모 환경에서의 VFIO 확장성 개선 방안을 다룹니다
• LWN: VFIO device migration — VFIO 장치 마이그레이션 프레임워크의 설계와 구현을 설명합니다

커널 소스

• drivers/vfio/vfio_main.c — VFIO 코어 프레임워크의 메인 소스입니다
• drivers/vfio/pci/ — VFIO-PCI 드라이버로, PCI 장치 패스스루를 담당합니다
• drivers/vfio/mdev/ — mdev 코어 모듈로, Mediated Device 프레임워크를 구현합니다
• include/linux/vfio.h — VFIO 코어 헤더 파일입니다
• include/uapi/linux/vfio.h — VFIO 사용자 공간 API 헤더로, ioctl 상수를 정의합니다
• include/linux/mdev.h — mdev 드라이버 인터페이스 헤더입니다
• drivers/gpu/drm/i915/gvt/ — Intel GVT-g 소스로, mdev 기반 GPU 가상화를 구현합니다

사양서

• Intel VT-d Specification — Intel의 I/O 가상화 기술(VT-d) 공식 사양서입니다
• AMD IOMMU Specification — AMD IOMMU 아키텍처 공식 사양서입니다
• PCI-SIG SR-IOV Specification — SR-IOV(Single Root I/O Virtualization) PCI-SIG 공식 사양서입니다

기타 자료

• QEMU VFIO documentation — QEMU에서의 VFIO 장치 에뮬레이션 공식 문서입니다
• Arch Wiki — PCI passthrough via OVMF — OVMF를 통한 PCI 패스스루 설정 가이드입니다

관련 문서