PCI / PCIe 서브시스템

PCI/PCIe 서브시스템을 하드웨어 링크 계층부터 Linux 커널 드라이버 통합 지점까지 end-to-end로 정리합니다. config space/BAR/MSI-X 같은 기본 메커니즘, 열거와 리소스 할당, IOMMU 연계 DMA 경로, AER 오류 보고와 복구, ASPM/D-state 전원관리, SR-IOV 및 VF 분리 운용, hotplug와 리셋 플로우, sysfs/lspci/setpci/tracepoint 기반 문제 분석까지 서버와 임베디드 환경 모두에서 필요한 실전 포인트를 다룹니다.

PCI/PCIe 개요

PCI (Peripheral Component Interconnect)는 1992년 Intel이 제안한 로컬 버스 규격으로, 이후 PCI Express (PCIe)로 진화하며 현대 시스템의 사실상 표준 인터커넥트가 되었습니다. Linux 커널은 PCI 서브시스템을 통해 디바이스 열거(enumeration), 리소스 할당, 드라이버 바인딩, 전원 관리(Power Management)를 통합적으로 처리합니다.

PCIe 아키텍처

토폴로지

PCIe는 기존 PCI의 공유 병렬 버스를 point-to-point 직렬 링크로 대체합니다. 트리 구조의 핵심 구성 요소:

PCIe 계층 구조

PCIe는 네트워크 프로토콜과 유사한 3계층 모델을 사용합니다:

TLP (Transaction Layer Packet)

TLP는 PCIe 통신의 핵심 단위입니다. 주요 TLP 타입:

TLP 헤더 포맷 상세

TLP 헤더는 3 DW (12 바이트) 또는 4 DW (16 바이트)로 구성됩니다. 첫 번째 DW의 Fmt[2:0] 필드가 헤더 길이와 데이터 유무를, Type[4:0] 필드가 트랜잭션 종류를 결정합니다:

Requester ID / Completer ID

TLP 라우팅의 핵심 식별자는 16비트 BDF (Bus:Device:Function)입니다:

• Requester ID: TLP를 발행한 디바이스의 BDF. Non-Posted 트랜잭션에서 Completion을 돌려받을 대상을 식별합니다.
• Completer ID: Completion TLP에 포함되어 어느 디바이스가 응답했는지 표시합니다.
• Tag: 동일 Requester가 여러 Non-Posted 요청을 동시 발행할 때 각 요청을 구분하는 8/10/14비트 식별자입니다. Extended Tag(PCIe 2.0, 10비트)와 14-bit Tag(PCIe 6.0)가 미해결 요청 수를 확장합니다.

크레딧 기반 흐름 제어 (Flow Control)

PCIe는 수신 측 버퍼 오버플로(Buffer Overflow)우를 방지하기 위해 크레딧 기반 흐름 제어를 사용합니다. 송신 측은 수신 측에서 통지한 크레딧만큼만 TLP를 전송할 수 있으며, 수신 측이 버퍼(Buffer)를 비운 후 UpdateFC DLLP로 크레딧을 반환합니다.

가상 채널과 트래픽 클래스 (VC/TC)

PCIe는 QoS 지원을 위해 TC (Traffic Class, 0~7)와 VC (Virtual Channel, 0~7)를 정의합니다. TC-to-VC 매핑(Mapping)은 VC Capability에서 설정하며, 각 VC는 독립적인 크레딧과 버퍼를 가집니다:

Data Link Layer — DLLP와 ACK/NAK

Data Link Layer는 TLP의 신뢰성 보장을 담당합니다. 모든 TLP에 시퀀스 번호와 LCRC를 추가하고, ACK/NAK 프로토콜로 전송 오류를 복구합니다:

LTSSM (Link Training and Status State Machine)

PCIe 물리 계층의 링크 초기화와 속도 협상은 LTSSM이 관리합니다. 링크 업부터 전원 절약 상태까지 모든 전환을 11개 주요 상태로 모델링합니다:

PCIe 등화 (Equalization) — Gen3+

PCIe Gen3 (8 GT/s) 이상에서는 고속 신호의 ISI(Inter-Symbol Interference)를 보상하기 위해 송수신 등화(Equalization)가 필수입니다:

PCIe 세대별 인코딩과 Gen6 FLIT 모드

PCIe 6.0 FLIT 모드

PCIe 6.0(Gen6)은 기존 TLP 바이트 스트림 프레이밍(Framing)을 FLIT(Flow Control Unit) 기반 전송으로 대체합니다. 이는 PCIe 도입 이후 가장 큰 프로토콜 변화입니다.

256바이트 FLIT 구조

하나의 FLIT는 고정 256바이트로 구성되며, 기존의 가변 길이 TLP/DLLP 프레이밍 대신 일정한 전송 단위를 사용합니다:

PCIe 5.0 vs 6.0 비교

Configuration Space

접근 방식

PCI Configuration Space에 접근하는 두 가지 메커니즘:

/* I/O 포트 방식 Configuration Space 접근 (레거시 PCI) */
/* CONFIG_ADDRESS (0xCF8):
 *   [31]    Enable bit
 *   [23:16] Bus number
 *   [15:11] Device number
 *   [10:8]  Function number
 *   [7:2]   Register number (DWORD-aligned)
 *   [1:0]   항상 0
 */
static u32 pci_conf1_read(u8 bus, u8 dev, u8 func, u8 reg)
{
    u32 addr = (1 << 31) |
              ((u32)bus << 16) |
              ((u32)dev << 11) |
              ((u32)func << 8) |
              (reg & 0xFC);
    outl(addr, 0xCF8);
    return inl(0xCFC);
}

/* ECAM (Enhanced Configuration Access Mechanism)
 * MMIO 베이스 + (Bus << 20 | Dev << 15 | Func << 12 | Reg)
 * 각 Function에 4 KB 매핑 → 4096 바이트 Config Space 전체 접근 */

ECAM 주소 계산

ECAM(Enhanced Configuration Access Mechanism)은 PCIe Configuration Space 전체(4096 바이트)를 MMIO로 직접 접근할 수 있게 합니다. ACPI MCFG 테이블에서 ECAM 베이스 주소를 획득하며, Bus/Device/Function/Register를 비트 시프트(Bit Shift)로 조합하여 물리 주소를 계산합니다:

Configuration Header 구조

모든 PCI/PCIe 디바이스는 Configuration Header (처음 64 바이트)를 가집니다:

Command 레지스터 (오프셋 04h)

드라이버가 디바이스를 제어하는 핵심 레지스터:

Capability 구조

오프셋(Offset) 34h의 Capabilities Pointer부터 시작하는 연결 리스트(linked list)로, 각 Capability는 ID + Next Pointer + 데이터로 구성됩니다:

PCIe 4 KB 확장 공간(256~4095)에는 Extended Capabilities가 위치합니다:

BAR (Base Address Registers)

BAR은 디바이스가 CPU에 노출하는 메모리/I/O 영역의 시작 주소를 정의합니다. Endpoint(Type 0)는 최대 6개, Bridge(Type 1)는 2개의 BAR을 가집니다.

BAR 크기 결정 알고리즘

BAR 크기는 다음 절차로 결정됩니다. 이는 PCI 스펙에 정의된 표준 메커니즘입니다:

/* 커널 내부: BAR 크기 결정 (drivers/pci/probe.c — 간략화) */
static u64 pci_size(u64 base, u64 maxbase, u64 mask)
{
    u64 size = mask & maxbase;  /* 타입 비트 마스킹 */
    if (!size)
        return 0;
    /* 1의 보수 + 1 = 2의 보수 = 크기
     * 예: size = 0xFFF00000 → ~size + 1 = 0x00100000 = 1 MB */
    size = (size & ~(size - 1)) - 1;  /* 최하위 set 비트 ~ 위 모두 포함 */
    if (base == maxbase && ((base | (size - 1)) & mask) != mask)
        return 0;
    return size + 1;
}

BAR 유형과 속성

/* 커널에서 BAR 정보 접근 */
struct pci_dev *pdev;

/* BAR의 물리 시작 주소 */
resource_size_t bar_start = pci_resource_start(pdev, 0);

/* BAR 영역 크기 */
resource_size_t bar_len = pci_resource_len(pdev, 0);

/* BAR 플래그 (IORESOURCE_MEM, IORESOURCE_IO 등) */
unsigned long bar_flags = pci_resource_flags(pdev, 0);

/* MMIO BAR을 가상 주소로 매핑 */
void __iomem *regs = pci_iomap(pdev, 0, bar_len);
if (!regs)
    return -ENOMEM;

/* MMIO 읽기/쓰기 */
u32 val = ioread32(regs + 0x10);
iowrite32(0x1, regs + 0x14);

/* 해제 */
pci_iounmap(pdev, regs);

Linux 커널 PCI 서브시스템

핵심 자료구조

struct pci_dev 주요 필드

struct pci_dev {
    struct pci_bus  *bus;             /* 디바이스가 연결된 버스 */
    unsigned int    devfn;            /* Device + Function 번호 (8비트) */
    unsigned short  vendor, device;   /* Vendor ID, Device ID */
    unsigned short  subsystem_vendor; /* Subsystem Vendor ID */
    unsigned short  subsystem_device; /* Subsystem Device ID */
    unsigned int    class;            /* Class Code (24비트) */
    u8              revision;         /* Revision ID */

    struct resource resource[PCI_NUM_RESOURCES]; /* BAR 리소스 */
    unsigned int    irq;              /* 할당된 IRQ 번호 */

    pci_power_t     current_state;    /* D0, D1, D2, D3hot, D3cold */
    unsigned int    is_busmaster:1;   /* Bus Master 활성화 여부 */
    unsigned int    msi_enabled:1;    /* MSI 활성화 여부 */
    unsigned int    msix_enabled:1;   /* MSI-X 활성화 여부 */

    struct pci_driver *driver;       /* 바인딩된 드라이버 */
    struct device    dev;             /* 범용 디바이스 모델 */
    /* ... */
};

struct pci_driver 주요 필드

/* include/linux/pci.h */
struct pci_driver {
    const char                *name;        /* 드라이버 이름 (sysfs, modinfo) */
    const struct pci_device_id  *id_table;   /* 지원 디바이스 목록 (NULL이면 모든 디바이스) */
    int  (*probe)(struct pci_dev *dev,
                  const struct pci_device_id *id); /* 디바이스 발견·초기화 */
    void (*remove)(struct pci_dev *dev);    /* 드라이버 언바인드·리소스 해제 */
    int  (*suspend)(struct pci_dev *dev,
                    pm_message_t state);           /* 레거시 suspend (PM_SLEEP) */
    int  (*resume)(struct pci_dev *dev);    /* 레거시 resume */
    void (*shutdown)(struct pci_dev *dev);  /* 시스템 종료 시 호출 */
    int  (*sriov_configure)(struct pci_dev *dev,
                            int num_vfs);          /* VF 수 설정 진입점 */
    int  (*sriov_set_msix_vec_count)(struct pci_dev *vf,
                                      int msix_vec_count); /* VF MSI-X 벡터 수 조정 */
    const struct pci_error_handlers *err_handler; /* AER 오류 복구 콜백 */
    const struct attribute_group   **groups;   /* sysfs 속성 그룹 */
    const struct attribute_group   **dev_groups; /* 디바이스별 sysfs 그룹 */
    struct device_driver           driver;    /* 드라이버 모델 기반 구조체 */
};

PCI 열거 (Enumeration)

커널 부팅 시 PCI 서브시스템은 다음 순서로 디바이스를 발견합니다:

1. ACPI/DT에서 Host Bridge 정보 수집 — MCFG 테이블(ECAM 베이스), _CRS(리소스 윈도우)
2. Bus 0부터 재귀적 스캔 — 각 Bus/Device/Function에 대해 Vendor ID 읽기 (0xFFFF이면 존재하지 않음)
3. Bridge(Type 1) 발견 시 — Secondary/Subordinate Bus Number 할당 후 하위 버스 재귀 탐색
4. BAR 크기 결정 및 리소스 할당 — 커널의 리소스 관리자가 주소 범위 배정
5. 드라이버 매칭 — pci_device_id 테이블 기반으로 드라이버 probe() 호출

/* 커널 내부: PCI 디바이스 스캔 핵심 경로 (simplified) */
/* drivers/pci/probe.c */

struct pci_dev *pci_scan_single_device(struct pci_bus *bus, int devfn)
{
    struct pci_dev *dev;

    dev = pci_get_slot(bus, devfn);
    if (dev)
        return dev;  /* 이미 스캔됨 */

    dev = pci_scan_device(bus, devfn);
    if (!dev)
        return NULL;

    pci_device_add(dev, bus);
    return dev;
}

pci_scan_bus() 호출 체인

커널 부팅 시 PCI 열거의 최상위 진입점은 pci_scan_bus()입니다. 이 함수는 버스 번호를 받아 하위 모든 디바이스를 재귀적으로 탐색하고 pci_dev 계층을 구성합니다.

/* drivers/pci/probe.c — 열거 핵심 3단계 호출 체인 */

/* [1단계] 버스 전체 스캔: 0~31번 슬롯 × 0~7번 function 순회 */
unsigned int pci_scan_child_bus(struct pci_bus *bus)
{
    unsigned int devfn, fn, pass, max = bus->busn_res.start;
    struct pci_dev *dev;

    for (devfn = 0; devfn < 256; devfn += 8)
        pci_scan_slot(bus, devfn);    /* 슬롯 하나 처리 */

    /* pass 0: 단말 디바이스(Type 0) 먼저 */
    /* pass 1: 브릿지(Type 1) 재귀 탐색 */
    for (pass = 0; pass < 2; pass++)
        list_for_each_entry(dev, &bus->devices, bus_list)
            if (pci_is_bridge(dev))
                max = pci_scan_bridge(bus, dev, max, pass);
    return max;
}

/* [2단계] 슬롯 스캔: Multi-Function 디바이스 처리 */
static int pci_scan_slot(struct pci_bus *bus, int devfn)
{
    int fn, nr = 0;
    struct pci_dev *dev;

    dev = pci_scan_single_device(bus, devfn);   /* Function 0 먼저 */
    if (!dev)
        return 0;
    if (!dev->multifunction)
        return 1;                               /* 단일 function이면 종료 */

    for (fn = 1; fn < 8; fn++) {               /* Function 1~7 추가 탐색 */
        dev = pci_scan_single_device(bus, devfn + fn);
        if (dev)
            nr++;
    }
    return nr;
}

/* [3단계] 단일 디바이스 등록: pci_dev 생성 및 버스 연결 */
struct pci_dev *pci_scan_single_device(struct pci_bus *bus, int devfn)
{
    struct pci_dev *dev;

    dev = pci_scan_device(bus, devfn);       /* Config Space 읽기 + pci_dev 할당 */
    if (!dev)
        return NULL;

    pci_device_add(dev, bus);               /* kobject + sysfs 등록 */
    return dev;
}

PCI 드라이버 작성

드라이버 골격

#include <linux/module.h>
#include <linux/pci.h>

#define MY_VENDOR_ID  0x1234
#define MY_DEVICE_ID  0x5678

struct my_priv {
    void __iomem *regs;
    /* 디바이스별 private 데이터 */
};

static int my_probe(struct pci_dev *pdev,
                    const struct pci_device_id *id)
{
    struct my_priv *priv;
    int err;

    /* 1. PCI 디바이스 활성화 */
    err = pcim_enable_device(pdev);
    if (err)
        return err;

    /* 2. BAR 리소스 요청 (managed) */
    err = pcim_iomap_regions(pdev, BIT(0), KBUILD_MODNAME);
    if (err)
        return err;

    /* 3. private 데이터 할당 */
    priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
    if (!priv)
        return -ENOMEM;

    /* 4. BAR 0 매핑 주소 획득 */
    priv->regs = pcim_iomap_table(pdev)[0];

    /* 5. DMA 마스크 설정 */
    err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
    if (err)
        return err;

    /* 6. Bus Master 활성화 (DMA 사용 시 필수) */
    pci_set_master(pdev);

    /* 7. MSI-X 인터럽트 설정 */
    err = pci_alloc_irq_vectors(pdev, 1, 16, PCI_IRQ_MSIX | PCI_IRQ_MSI);
    if (err < 0)
        return err;

    pci_set_drvdata(pdev, priv);

    dev_info(&pdev->dev, "probed successfully\\n");
    return 0;
}

static void my_remove(struct pci_dev *pdev)
{
    /* pcim_* / devm_* 사용 시 자동 정리 — 명시적 해제 불필요 */
    pci_free_irq_vectors(pdev);
    dev_info(&pdev->dev, "removed\\n");
}

/* PCI Device ID 테이블 — 드라이버가 지원하는 디바이스 목록 */
static const struct pci_device_id my_pci_ids[] = {
    { PCI_DEVICE(MY_VENDOR_ID, MY_DEVICE_ID) },
    { PCI_DEVICE_CLASS(PCI_CLASS_NETWORK_ETHERNET << 8, 0xFFFF00) },
    { 0, }  /* 종료 마커 */
};
MODULE_DEVICE_TABLE(pci, my_pci_ids);

static struct pci_driver my_driver = {
    .name     = KBUILD_MODNAME,
    .id_table = my_pci_ids,
    .probe    = my_probe,
    .remove   = my_remove,
};
module_pci_driver(my_driver);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Example PCI driver");

Managed API (pcim_* / devm_*)

커널은 Managed Device Resource API를 제공하여 드라이버 해제 시 자동 정리합니다:

PCI ID 매칭 매크로(Macro)

드라이버 매칭 내부 구현

pci_register_driver() 호출 시 커널 드라이버 모델이 이미 등록된 PCI 디바이스와 새 드라이버의 id_table을 매칭합니다. 새 디바이스가 발견될 때도 동일한 경로가 역방향으로 동작합니다.

/* drivers/pci/pci-driver.c — 드라이버 매칭 핵심 경로 */

/* [1단계] 버스 레벨 매칭: pci_bus_match()
 * 디바이스 모델이 driver_attach() → __driver_attach() → driver_match_device()
 * 를 통해 호출합니다. */
static int pci_bus_match(struct device *dev, struct device_driver *drv)
{
    struct pci_dev    *pci_dev  = to_pci_dev(dev);
    struct pci_driver *pci_drv  = to_pci_driver(drv);
    const struct pci_device_id *found_id;

    /* id_table의 각 엔트리를 순회하며 vendor/device/class 매칭 */
    found_id = pci_match_device(pci_drv, pci_dev);
    return found_id != NULL;
}

/* [2단계] ID 매칭: pci_match_device()
 * 드라이버의 id_table + 동적 ID 리스트 양쪽을 검사합니다. */
static const struct pci_device_id *
pci_match_device(struct pci_driver *drv, struct pci_dev *dev)
{
    const struct pci_device_id *id;

    /* 정적 id_table 검색 */
    id = pci_match_id(drv->id_table, dev);
    if (id)
        return id;

    /* sysfs new_id를 통해 런타임 추가된 동적 ID 검색 */
    spin_lock(&drv->dynids.lock);
    list_for_each_entry(dynid, &drv->dynids.list, node) {
        if (pci_match_one_device(&dynid->id, dev)) {
            id = &dynid->id;
            break;
        }
    }
    spin_unlock(&drv->dynids.lock);
    return id;
}

/* [3단계] 개별 ID 비교: pci_match_one_device()
 * vendor/device/subvendor/subdevice/class 5개 필드를 비교합니다. */
static inline const struct pci_device_id *
pci_match_one_device(const struct pci_device_id *id,
                     const struct pci_dev *dev)
{
    if ((id->vendor == PCI_ANY_ID || id->vendor == dev->vendor) &&
        (id->device == PCI_ANY_ID || id->device == dev->device) &&
        (id->subvendor == PCI_ANY_ID || id->subvendor == dev->subsystem_vendor) &&
        (id->subdevice == PCI_ANY_ID || id->subdevice == dev->subsystem_device) &&
        !((id->class ^ dev->class) & id->class_mask))
        return id;
    return NULL;
}

probe() 호출 내부 경로

매칭이 성공하면 pci_device_probe()가 호출되어 드라이버의 probe() 콜백을 실행합니다. 이 과정에서 디바이스 활성화와 리소스 준비가 이루어집니다.

/* drivers/pci/pci-driver.c — probe 호출 체인 (simplified) */

static int pci_device_probe(struct device *dev)
{
    struct pci_dev    *pci_dev = to_pci_dev(dev);
    struct pci_driver *drv     = to_pci_driver(dev->driver);
    const struct pci_device_id *id;
    int error;

    /* 디바이스의 NUMA 노드에서 probe 실행 (캐시 친화도) */
    error = pci_call_probe(drv, pci_dev, id);
    return error;
}

static int pci_call_probe(struct pci_driver *drv,
                          struct pci_dev *dev,
                          const struct pci_device_id *id)
{
    int error, node, cpu;

    /* NUMA 노드 기반 CPU 선택 → work_on_cpu()로 해당 노드에서 실행 */
    node = dev_to_node(&dev->dev);
    if (node >= 0 && node != numa_node_id()) {
        cpu = cpumask_any_and(cpumask_of_node(node),
                               cpu_online_mask);
        if (cpu < nr_cpu_ids)
            error = work_on_cpu(cpu, local_pci_probe, &ddi);
        else
            error = local_pci_probe(&ddi);
    } else {
        error = local_pci_probe(&ddi);
    }
    return error;
}

static long local_pci_probe(void *_ddi)
{
    struct drv_dev_and_id *ddi = _ddi;
    struct pci_dev *pci_dev = ddi->dev;
    struct pci_driver *pci_drv = ddi->drv;
    int rc;

    /* PM 런타임 레퍼런스 획득 */
    pm_runtime_get_sync(&pci_dev->dev);

    /* ★ 드라이버의 probe() 콜백 호출 */
    rc = pci_drv->probe(pci_dev, ddi->id);
    if (rc)
        pm_runtime_put_sync(&pci_dev->dev);

    return rc;
}

드라이버 언바인드와 sysfs 제어

# 드라이버 수동 언바인드
echo "0000:03:00.0" > /sys/bus/pci/drivers/nvme/unbind

# 다른 드라이버에 바인딩 (예: vfio-pci)
echo "vfio-pci" > /sys/bus/pci/devices/0000:03:00.0/driver_override
echo "0000:03:00.0" > /sys/bus/pci/drivers_probe

# driver_override 초기화 (자동 매칭으로 복원)
echo "" > /sys/bus/pci/devices/0000:03:00.0/driver_override

# 동적 ID 추가 (런타임에 드라이버가 새 디바이스를 지원하도록)
echo "8086 1572" > /sys/bus/pci/drivers/vfio-pci/new_id
# → pci_match_device()가 dynids 리스트에서 이 ID를 찾음

# 동적 ID 제거
echo "8086 1572" > /sys/bus/pci/drivers/vfio-pci/remove_id

DMA 매핑

PCI 디바이스가 시스템 메모리에 직접 접근하려면 DMA (Direct Memory Access)를 사용합니다. 커널은 두 가지 DMA 매핑 모델을 제공합니다:

Coherent (Consistent) DMA

CPU와 디바이스가 동시에 접근하는 공유 메모리에 적합합니다. 캐시(Cache) 코히런시가 하드웨어적으로 보장됩니다.

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

/* 할당: CPU 가상 주소 + DMA 버스 주소 반환 */
cpu_addr = dma_alloc_coherent(&pdev->dev, size, &dma_handle, GFP_KERNEL);
if (!cpu_addr)
    return -ENOMEM;

/* 디바이스에 DMA 주소 전달 (레지스터에 기록) */
iowrite32(lower_32_bits(dma_handle), regs + 0x20);
iowrite32(upper_32_bits(dma_handle), regs + 0x24);

/* 해제 */
dma_free_coherent(&pdev->dev, size, cpu_addr, dma_handle);

Streaming DMA

일시적 단방향 전송에 적합합니다. 매핑 전후 명시적 캐시 동기화가 필요합니다.

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

/* 매핑: CPU 버퍼 → DMA 주소 */
dma_handle = dma_map_single(&pdev->dev, buf, 4096, DMA_TO_DEVICE);
if (dma_mapping_error(&pdev->dev, dma_handle)) {
    kfree(buf);
    return -EIO;
}

/* 디바이스가 DMA 전송 수행... */

/* 언매핑 (반드시 전송 완료 후) */
dma_unmap_single(&pdev->dev, dma_handle, 4096, DMA_TO_DEVICE);
kfree(buf);

DMA 방향

Scatter-Gather DMA

물리적으로 불연속적인 메모리 페이지를 하나의 DMA 전송으로 처리합니다:

struct scatterlist sg[MAX_SG];
int nents, mapped;

sg_init_table(sg, MAX_SG);
/* sg 엔트리에 페이지/오프셋/길이 설정 */
sg_set_page(&sg[0], page0, 4096, 0);
sg_set_page(&sg[1], page1, 4096, 0);

/* 매핑: IOMMU가 있으면 연속 DMA 주소로 합칠 수 있음 */
mapped = dma_map_sg(&pdev->dev, sg, nents, DMA_FROM_DEVICE);

/* 언매핑 */
dma_unmap_sg(&pdev->dev, sg, nents, DMA_FROM_DEVICE);

IOMMU / DMA Remapping

IOMMU(Intel VT-d, AMD-Vi)는 디바이스의 DMA 주소를 물리 주소(Physical Address)로 변환하는 하드웨어입니다:

커널 부팅 파라미터:
  intel_iommu=on        # Intel VT-d 활성화
  iommu=pt              # Passthrough 모드 (성능 우선, 격리 최소)
  iommu.strict=1        # Strict 모드 (보안 우선, 즉시 IOTLB 무효화)

MSI / MSI-X 인터럽트

PCI 레거시 인터럽트(INTA#~INTD#)는 공유 인터럽트 라인 문제가 있습니다. MSI (Message Signaled Interrupt)와 MSI-X는 메모리 쓰기(TLP) 방식으로 인터럽트를 전달하여 이 문제를 해결합니다.

MSI Capability 구조 (Cap ID 05h)

MSI Capability는 PCI Configuration Space의 Capability List에 연결되며, Cap ID 05h로 식별됩니다. Message Control Register의 설정에 따라 32비트/64비트 주소와 Per-Vector Masking 지원 여부가 결정됩니다.

Message Control Register (Offset 02h)

MSI Capability 레이아웃

Message Address Register (MAR) — x86 APIC 인코딩

x86에서 MSI Message Address는 LAPIC의 메모리 매핑 영역(0xFEExxxxx)을 가리킵니다.

비트 31:20  0xFEE (고정 — LAPIC 기본 주소 상위 12비트)
비트 19:12  Destination ID (target APIC ID)
비트    11  Reserved
비트    10  Reserved
비트     4  Redirection Hint (RH)
           0 = Destination ID가 직접 타겟 지정
           1 = 로직 모드에서 lowest-priority 가능
비트     3  Destination Mode (DM)
           0 = Physical Mode (APIC ID 직접)
           1 = Logical Mode (클러스터/flat)
비트   2:0  Reserved

Message Data Register (MDR)

비트  7:0   Vector (IDT 엔트리 번호, 0x10~0xFE)
비트 10:8   Delivery Mode
            000 = Fixed, 001 = Lowest Priority
            010 = SMI,   100 = NMI
            101 = INIT,  111 = ExtINT
비트   11   Reserved
비트   12   Reserved
비트   13   Reserved
비트   14   Level (edge: 무시, level: 0=deassert, 1=assert)
비트   15   Trigger Mode (0=Edge, 1=Level)
비트 31:16  Reserved (PCIe 4.0 확장 시 사용)

MSI-X Capability 구조 (Cap ID 11h)

MSI-X는 MSI의 제한(최대 32벡터, 단일 MAR/MDR)을 극복하기 위해 도입되었습니다. 별도의 BAR 영역에 벡터 테이블과 PBA를 배치하여, 최대 2048개 벡터를 각각 독립적으로 구성할 수 있습니다.

MSI-X Message Control Register (Offset 02h)

MSI-X Capability + Table Entry 레이아웃

PBA (Pending Bit Array)

PBA는 벡터가 마스크된 동안 발생한 인터럽트를 기록합니다. 각 비트가 테이블 엔트리에 1:1 대응하며, 벡터 언마스크 시 pending 비트가 설정되어 있으면 인터럽트가 즉시 전달됩니다. PBA는 읽기 전용(Read-Only)이며, 하드웨어가 자동으로 관리합니다.

/* 커널 내부: MSI-X 벡터 개별 마스킹 (drivers/pci/msi/msi.c) */
static void msix_mask_irq(struct msi_desc *desc)
{
    void __iomem *addr = desc->pci.mask_base +
                         desc->msi_index * PCI_MSIX_ENTRY_SIZE +
                         PCI_MSIX_ENTRY_VECTOR_CTRL;
    u32 ctrl = readl(addr);
    ctrl |= PCI_MSIX_ENTRY_CTRL_MASKBIT;
    writel(ctrl, addr);
    /* readl() — 쓰기가 디바이스에 도달했음을 보장 (flush) */
    readl(addr);
}

static void msix_unmask_irq(struct msi_desc *desc)
{
    void __iomem *addr = desc->pci.mask_base +
                         desc->msi_index * PCI_MSIX_ENTRY_SIZE +
                         PCI_MSIX_ENTRY_VECTOR_CTRL;
    u32 ctrl = readl(addr);
    ctrl &= ~PCI_MSIX_ENTRY_CTRL_MASKBIT;
    writel(ctrl, addr);
    readl(addr);
}

인터럽트 전달 메커니즘

MSI/MSI-X 인터럽트는 디바이스가 특정 주소로 Memory Write TLP를 전송하는 방식으로 동작합니다. 플랫폼에 따라 전달 경로가 다릅니다.

x86: LAPIC 기반 전달

디바이스가 0xFEE00000 범위의 주소로 Memory Write TLP를 전송하면, PCIe Root Complex가 이를 메모리 트랜잭션이 아닌 인터럽트 메시지로 인식하여 대상 CPU의 LAPIC에 전달합니다.

ARM: ITS (Interrupt Translation Service) 기반 전달

ARM GICv3/v4에서는 ITS가 MSI 메시지를 수신하여 DeviceID + EventID를 LPI(Locality-specific Peripheral Interrupt) 번호로 변환합니다. ITS Command Queue를 통해 매핑 테이블이 관리됩니다.

IRR(Interrupt Request Register): LAPIC 내부 레지스터로, 아직 서비스되지 않은 대기 중인 인터럽트 벡터 비트를 저장합니다. CPU가 인터럽트를 처리하기 시작하면 해당 비트가 ISR(In-Service Register)로 이동합니다.

커널 MSI 서브시스템

리눅스 커널의 MSI 서브시스템은 irq_domain 계층 구조를 기반으로, 플랫폼별 인터럽트 컨트롤러(Interrupt Controller)와 PCI MSI를 추상화합니다.

주요 구조체

pci_alloc_irq_vectors() 내부 구현

드라이버가 pci_alloc_irq_vectors()를 호출하면 커널은 MSI-X → MSI → Legacy INTx 순서로 시도합니다. 내부 호출 체인을 추적하면 다음과 같습니다.

/* drivers/pci/msi/api.c — 진입점 */
int pci_alloc_irq_vectors(struct pci_dev *dev,
                          unsigned int min_vecs,
                          unsigned int max_vecs,
                          unsigned int flags)
{
    return pci_alloc_irq_vectors_affinity(dev, min_vecs,
                                           max_vecs, flags, NULL);
}

/* drivers/pci/msi/api.c — affinity 포함 벡터 할당 */
int pci_alloc_irq_vectors_affinity(
    struct pci_dev *dev,
    unsigned int min_vecs, unsigned int max_vecs,
    unsigned int flags, struct irq_affinity *affd)
{
    struct irq_affinity msi_default_affd = { 0 };
    int nvecs = -ENOSPC;

    if (flags & PCI_IRQ_AFFINITY) {
        if (!affd)
            affd = &msi_default_affd;
    } else {
        affd = NULL;
    }

    /* 1순위: MSI-X 시도 */
    if (flags & PCI_IRQ_MSIX) {
        nvecs = __pci_enable_msix_range(dev, NULL,
                    min_vecs, max_vecs, affd, flags);
        if (nvecs > 0)
            return nvecs;
    }

    /* 2순위: MSI 폴백 */
    if (flags & PCI_IRQ_MSI) {
        nvecs = __pci_enable_msi_range(dev,
                    min_vecs, max_vecs, affd);
        if (nvecs > 0)
            return nvecs;
    }

    /* 3순위: Legacy INTx 폴백 (min_vecs가 1이어야 가능) */
    if (flags & PCI_IRQ_LEGACY) {
        if (min_vecs == 1 && dev->irq)
            return 1;
    }
    return nvecs;
}

/* drivers/pci/msi/msi.c — MSI-X 활성화 내부 핵심 경로 (simplified) */

static int msix_capability_init(struct pci_dev *dev,
                                struct msix_entry *entries,
                                int nvec,
                                struct irq_affinity *affd)
{
    void __iomem *base;
    int ret;
    u16 control;

    /* MSI-X Capability의 Message Control 읽기 */
    pci_read_config_word(dev,
        dev->msix_cap + PCI_MSIX_FLAGS, &control);

    /* MSI-X 테이블의 BAR 영역을 MMIO 매핑 */
    base = msix_map_region(dev, msix_table_size(control));
    if (!base)
        return -ENOMEM;

    /* 모든 벡터를 먼저 마스크 (Function Mask 비트 설정) */
    pci_write_config_word(dev,
        dev->msix_cap + PCI_MSIX_FLAGS,
        control | PCI_MSIX_FLAGS_MASKALL);

    /* irq_domain을 통해 Linux IRQ 벡터 할당 */
    ret = msix_setup_interrupts(dev, base, entries, nvec, affd);
    if (ret)
        goto out_free;

    /* MSI-X Enable 비트 설정 + Function Mask 해제 */
    pci_write_config_word(dev,
        dev->msix_cap + PCI_MSIX_FLAGS,
        control | PCI_MSIX_FLAGS_ENABLE);

    /* INTx 비활성화 (MSI-X와 공존 불가) */
    pci_intx_for_msi(dev, 0);
    dev->msix_enabled = 1;
    return 0;

out_free:
    pci_write_config_word(dev,
        dev->msix_cap + PCI_MSIX_FLAGS, control);
    return ret;
}

msi_msg / msi_desc 코드

/* include/linux/msi.h */
struct msi_msg {
    union {
        u64 address;
        struct {
            u32 address_lo;   /* MAR 하위 32비트 */
            u32 address_hi;   /* MAR 상위 32비트 (64-bit) */
        };
    };
    u32 data;             /* MDR — 벡터, 전달 모드 등 */
};

struct msi_desc {
    unsigned int        irq;          /* Linux IRQ 번호 */
    unsigned int        nvec_used;    /* 사용 벡터 수 */
    struct device       *dev;          /* 소유 디바이스 */
    struct msi_msg      msg;           /* 현재 프로그래밍된 메시지 */
    struct irq_affinity_desc *affinity; /* CPU affinity */
    struct {
        u32         masked;       /* MSI: Mask Bits 캐시 */
        struct {
            u8      is_64;    /* 64비트 주소 지원 */
            u16     entry_nr; /* MSI-X 테이블 인덱스 */
            void __iomem *mask_base; /* MSI-X 테이블 VA */
        } pci;
    };
    u16                 msi_index;    /* 벡터 인덱스 */
};

pci_alloc_irq_vectors() 내부 흐름

드라이버가 pci_alloc_irq_vectors()를 호출하면, 커널은 다음 순서로 벡터를 할당합니다.

커널 소스 경로

벡터 할당과 CPU Affinity

멀티코어 시스템에서 인터럽트를 적절한 CPU에 분배하는 것은 성능에 결정적입니다. 커널은 NUMA 토폴로지를 고려한 자동 affinity 할당을 지원합니다.

pci_alloc_irq_vectors 플래그

NVMe 스타일 affinity 벡터 할당

/* MSI-X 할당 — 커널이 최적 벡터 수 결정 + 자동 affinity */
struct irq_affinity affd = {
    .pre_vectors  = 1,  /* Admin Queue 전용 벡터 (affinity 제외) */
    .post_vectors = 0,
};

int nvecs = pci_alloc_irq_vectors_affinity(pdev,
    1,           /* 최소 벡터 수 */
    num_queues,  /* 최대 벡터 수 (보통 I/O 큐 수 + 1) */
    PCI_IRQ_MSIX | PCI_IRQ_MSI | PCI_IRQ_AFFINITY,
    &affd);

if (nvecs < 0)
    return nvecs;

/* 각 벡터에 대한 IRQ 번호 획득 및 핸들러 등록 */
for (int i = 0; i < nvecs; i++) {
    int irq = pci_irq_vector(pdev, i);

    err = devm_request_irq(&pdev->dev, irq, my_isr, 0,
                           KBUILD_MODNAME, &queues[i]);
    if (err)
        goto err_free;
}

/* ... 드라이버 운영 ... */

/* 해제 — devm 사용 시 자동 해제, 수동 시: */
pci_free_irq_vectors(pdev);

sysfs affinity 인터페이스

# 특정 IRQ의 현재 affinity 확인
cat /proc/irq/<irq_num>/smp_affinity_list
# 출력 예: 0-3  (CPU 0~3에 분배)

# affinity를 CPU 4로 변경
echo 4 > /proc/irq/<irq_num>/smp_affinity_list

# managed_irq인 경우 (커널이 관리, 사용자 변경 불가)
cat /proc/irq/<irq_num>/effective_affinity_list

# NUMA 노드별 인터럽트 분포 확인
for irq in /proc/irq/*/smp_affinity_list; do
    echo "$(dirname $irq | xargs basename): $(cat $irq)"
done | sort -t: -k2 -n

Interrupt Remapping (IOMMU)

Intel VT-d 또는 AMD-Vi의 Interrupt Remapping (IR)은 디바이스가 전송하는 MSI 메시지를 IOMMU가 중간에서 변환하여, 보안 격리와 유연한 인터럽트 라우팅을 제공합니다.

호환 형식 vs 리매핑 형식

Posted Interrupts (VM 패스스루)

VT-d Posted Interrupts는 물리 디바이스의 MSI가 VM의 가상 APIC에 직접 주입되도록 합니다. vCPU가 실행 중이면 VM-Exit 없이 인터럽트가 전달되어, VFIO 패스스루 성능을 크게 향상시킵니다.

Posted Interrupt 흐름:
  Device → MSI TLP → IOMMU → IRTE (Posted Interrupt Descriptor 참조)
    ├─ vCPU 실행 중: PI Notification → 가상 APIC 직접 주입 (no VM-Exit)
    └─ vCPU 대기 중: Outstanding Notification → wakeup → VM-Entry 시 주입

멀티큐 드라이버 패턴

최신 고성능 디바이스는 하드웨어 멀티큐를 지원하며, 각 큐에 개별 MSI-X 벡터를 할당하여 CPU별 독립적인 인터럽트 처리가 가능합니다.

디바이스별 큐 구조

멀티큐 드라이버 코드 패턴

static int mydev_setup_irqs(struct pci_dev *pdev,
                             struct mydev_priv *priv)
{
    int num_cpus = num_online_cpus();
    int nvecs, i;
    struct irq_affinity affd = {
        .pre_vectors  = 1,  /* 관리용 벡터 */
        .post_vectors = 0,
    };

    /* MSI-X 우선 → MSI 폴백 → Legacy 폴백 */
    nvecs = pci_alloc_irq_vectors_affinity(pdev,
        2,              /* 최소: admin + I/O 1개 */
        num_cpus + 1,   /* 최대: admin + CPU당 1개 */
        PCI_IRQ_ALL_TYPES | PCI_IRQ_AFFINITY,
        &affd);

    if (nvecs < 0)
        return nvecs;

    priv->num_io_queues = nvecs - 1;

    /* 벡터 0: Admin Queue */
    if (devm_request_irq(&pdev->dev,
            pci_irq_vector(pdev, 0),
            mydev_admin_isr, 0,
            "mydev-admin", priv))
        goto err_free;

    /* 벡터 1~N: I/O Queues */
    for (i = 0; i < priv->num_io_queues; i++) {
        int irq = pci_irq_vector(pdev, i + 1);

        if (devm_request_irq(&pdev->dev, irq,
                mydev_io_isr, 0,
                "mydev-io", &priv->io_queues[i]))
            goto err_free;
    }

    return 0;

err_free:
    pci_free_irq_vectors(pdev);
    return -ENOMEM;
}

디버깅(Debugging)과 모니터링

MSI/MSI-X 관련 문제를 진단할 때 사용하는 주요 도구와 인터페이스입니다.

/proc/interrupts 해석

# MSI-X 벡터별 인터럽트 카운트 확인
grep "nvme" /proc/interrupts
#            CPU0       CPU1       CPU2       CPU3
# 36:      15234          0          0          0  IR-PCI-MSIX  0-edge  nvme0q0
# 37:          0      28451          0          0  IR-PCI-MSIX  1-edge  nvme0q1
# 38:          0          0      31205          0  IR-PCI-MSIX  2-edge  nvme0q2
# 39:          0          0          0      29876  IR-PCI-MSIX  3-edge  nvme0q3
# → IR-PCI-MSIX: Interrupt Remapping + PCI MSI-X
# → 각 큐가 서로 다른 CPU에 할당되어 있음 확인

lspci -vvv MSI Capability 디코딩

# MSI/MSI-X Capability 상세 확인
lspci -vvv -s 01:00.0 | grep -A 10 -E "MSI:|MSI-X:"
# Capabilities: [68] MSI: Enable- Count=1/1 Maskable- 64bit+
#         Address: 0000000000000000  Data: 0000
# Capabilities: [a0] MSI-X: Enable+ Count=65 Masked-
#         Vector table: BAR=0 offset=00002000
#         PBA: BAR=0 offset=00003000
# → Enable+: MSI-X 활성화 상태
# → Count=65: 65개 벡터 테이블 엔트리
# → BAR=0 offset=00002000: BAR 0의 0x2000에 벡터 테이블

sysfs + dmesg 확인

# 디바이스의 MSI 활성화 상태 확인
cat /sys/bus/pci/devices/0000:01:00.0/msi_irqs/*
# 또는
ls /sys/bus/pci/devices/0000:01:00.0/msi_irqs/
# 36 37 38 39  → 할당된 IRQ 번호 목록

# MSI 활성화 여부
cat /sys/bus/pci/devices/0000:01:00.0/msi_bus

# 커널 부팅 시 MSI 관련 메시지 확인
dmesg | grep -i "msi\|irq.*vector"
# [    1.234] nvme 0000:01:00.0: enabling device (0000 -> 0002)
# [    1.235] nvme 0000:01:00.0: PCI->APIC IRQ transform: INT A -> IRQ 36
# [    1.236] nvme nvme0: 4/0/0 default/read/poll queues

디버깅 도구 요약

SR-IOV (Single Root I/O Virtualization)

SR-IOV는 하나의 물리 PCIe 디바이스(PF)를 여러 개의 가상 기능(VF)으로 분할하여, 각 VF를 독립적인 VM 또는 컨테이너에 직접 할당(passthrough)할 수 있게 하는 하드웨어 가상화 기술입니다.

AER (Advanced Error Reporting)

PCIe AER는 에러를 Correctable과 Uncorrectable (Non-Fatal / Fatal)로 분류하여 보고합니다:

/* PCI 드라이버에서 AER 에러 복구 콜백 등록 */
static pci_ers_result_t
my_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
{
    if (state == pci_channel_io_perm_failure)
        return PCI_ERS_RESULT_DISCONNECT;

    /* I/O 중단, 리소스 정리 */
    my_stop_io(pdev);
    return PCI_ERS_RESULT_NEED_RESET;
}

static pci_ers_result_t
my_slot_reset(struct pci_dev *pdev)
{
    /* 디바이스 재초기화 */
    if (my_reinit_hw(pdev))
        return PCI_ERS_RESULT_DISCONNECT;
    return PCI_ERS_RESULT_RECOVERED;
}

static void my_resume(struct pci_dev *pdev)
{
    /* I/O 재개 */
    my_restart_io(pdev);
}

static const struct pci_error_handlers my_err_handler = {
    .error_detected = my_error_detected,
    .slot_reset     = my_slot_reset,
    .resume         = my_resume,
};

static struct pci_driver my_driver = {
    /* ... */
    .err_handler = &my_err_handler,
};

AER Extended Capability 레지스터

AER Extended Capability (ID 0001h)는 PCIe 확장 Config Space (오프셋 0x100+)에 위치하며, 에러 감지/보고/마스킹을 제어합니다:

# AER 에러 카운터 확인 (sysfs)
cat /sys/bus/pci/devices/0000:03:00.0/aer_dev_correctable
# RxErr 0 BadTLP 12 BadDLLP 0 Rollover 0 Timeout 0 NonFatalErr 0 ...

cat /sys/bus/pci/devices/0000:03:00.0/aer_dev_nonfatal
# Undefined 0 DLP 0 SDES 0 TLP 0 FCP 0 CmpltTO 3 CmpltAbrt 0 ...

# AER 에러 주입 (디버깅/테스트용)
echo 1 > /sys/kernel/debug/pci-error-inject/0000:03:00.0/inject_uncorrectable
# (CONFIG_PCIEAER_INJECT=y 필요)

# AER 트레이스포인트 활성화
echo 1 > /sys/kernel/debug/tracing/events/ras/aer_event/enable
cat /sys/kernel/debug/tracing/trace_pipe
# aer_event: 0000:03:00.0 PCIe Bus Error: severity=Corrected, type=Data Link Layer ...

AER 에러 처리 전체 흐름

DPC (Downstream Port Containment)

DPC는 PCIe 3.1에서 도입된 에러 격리 메커니즘으로, Uncorrectable Error 발생 시 해당 다운스트림 포트를 자동으로 비활성화하여 에러가 상위 버스로 전파되는 것을 방지합니다:

DPC Extended Capability (ID 001Dh) 핵심 레지스터:

DPC Control Register:

DPC Status Register:

Linux DPC 드라이버 (drivers/pci/pcie/dpc.c) 트리거 발생 시 처리 흐름:

1. dpc_irq() ISR 호출 → 워크큐로 지연 처리
2. dpc_process_error() — Header Log 읽기, 에러 원인 로깅
3. pcie_do_recovery() 호출 — AER와 동일한 복구 경로 사용
4. 복구 성공 시 DPC Trigger Status 클리어 → 포트 재활성화

# DPC Capability 확인
lspci -vvv -s 00:1c.0 | grep -A 5 "Downstream Port Containment"
#   DpcCap: INT Msg #0, RPExt+ PoisonedTLP+ SwTrigger+ RP PIO Log 4 ...
#   DpcCtl: Trigger:2 Cmpl+ INT+ ERR_COR- ...
#   DpcSta: Trigger- Reason:00 ...

# DPC 이벤트 로그
dmesg | grep -i dpc
# pcieport 0000:00:1c.0: DPC: containment event, status:0x1f01 source:0x0300

ACS (Access Control Services)

ACS는 PCIe 디바이스 간의 직접 통신(peer-to-peer)을 제어하여 IOMMU 격리를 강화합니다. 가상화 환경에서 VF 간의 트래픽이 IOMMU를 우회하는 것을 방지합니다:

# ACS Capability 확인
lspci -vvv -s 00:1c.0 | grep -A 3 "Access Control Services"
# ACSCap: SrcValid+ TransBlk+ ReqRedir+ CmpltRedir+ UpFwd- EgressCtrl- DirectTrans-
# ACSCtl: SrcValid+ TransBlk+ ReqRedir+ CmpltRedir+ UpFwd- EgressCtrl- DirectTrans-

# IOMMU 그룹 확인 (ACS의 결과)
find /sys/kernel/iommu_groups/ -type l | sort -V
# /sys/kernel/iommu_groups/1/devices/0000:03:00.0
# /sys/kernel/iommu_groups/2/devices/0000:04:00.0  ← ACS 덕분에 별도 그룹

전원 관리

PCI 전원 상태 (D-States)

/* PCI 드라이버 전원 관리 콜백 */
static int my_suspend(struct device *dev)
{
    struct pci_dev *pdev = to_pci_dev(dev);

    /* 디바이스 I/O 중단, 상태 저장 */
    my_stop_hw(pdev);
    pci_save_state(pdev);
    pci_disable_device(pdev);
    pci_set_power_state(pdev, PCI_D3hot);
    return 0;
}

static int my_resume(struct device *dev)
{
    struct pci_dev *pdev = to_pci_dev(dev);

    pci_set_power_state(pdev, PCI_D0);
    pci_restore_state(pdev);
    pci_enable_device(pdev);
    pci_set_master(pdev);
    my_start_hw(pdev);
    return 0;
}

static DEFINE_SIMPLE_DEV_PM_OPS(my_pm_ops, my_suspend, my_resume);

static struct pci_driver my_driver = {
    /* ... */
    .driver.pm = pm_sleep_ptr(&my_pm_ops),
};

ASPM (Active State Power Management)

PCIe 링크가 유휴 상태(Idle State)일 때 자동으로 저전력 링크 상태로 전환합니다:

# ASPM 정책 확인 및 설정
cat /sys/module/pcie_aspm/parameters/policy
# [default] performance powersave powersupersave

# 커널 부팅 파라미터
pcie_aspm=off           # ASPM 완전 비활성화 (저지연 요구 시)
pcie_aspm.policy=powersave  # 절전 우선

L1 서브스테이트 (L1.1 / L1.2) 상세

PCIe 3.1에서 도입된 L1 PM Substates (Extended Capability ID 001Eh)는 L1 상태 내에서 더 세밀한 전력 절약을 제공합니다:

# L1 Substates Capability 확인
lspci -vvv -s 03:00.0 | grep -A 10 "L1 PM Substates"
# L1SubCap: PCI-PM_L1.2+ PCI-PM_L1.1+ ASPM_L1.2+ ASPM_L1.1+ L1_PM_Substates+
#           PortCommonModeRestoreTime=60us PortTPowerOnTime=10us
# L1SubCtl1: PCI-PM_L1.2+ PCI-PM_L1.1+ ASPM_L1.2+ ASPM_L1.1+
#            T_CommonMode=0us LTR1.2_Threshold=163840ns

# LTR (Latency Tolerance Reporting) 확인
lspci -vvv -s 03:00.0 | grep LTR
# LTR+  DevCtl2: ... LTRen+
# LTR Max snoop latency: 3145728ns
# LTR Max no snoop latency: 3145728ns

# CLKREQ# 핀 상태 확인 (플랫폼 의존)
# L1.2 진입에는 CLKREQ# 핀이 물리적으로 연결되어야 합니다.
# 서버에서는 CLKREQ#가 연결되지 않아 L1.2 불가능한 경우가 많습니다.

PCIe 리셋 메커니즘

PCIe는 여러 수준의 리셋을 정의하며, 각 리셋의 범위와 복원 수준이 다릅니다:

/* 커널에서 PCIe 리셋 수행 */

/* 1. FLR (Function Level Reset) — 가장 세밀한 리셋 */
int ret = pci_reset_function(pdev);
/* FLR → AF FLR → PM Reset → Bus Reset 순서로 시도
 * pci_probe_reset_function()으로 지원 여부 확인 가능 */

/* 2. 잠금 없는 FLR (드라이버 내부에서 직접 호출 시) */
pci_reset_function_locked(pdev);

/* 3. Secondary Bus Reset — 하위 버스 전체 리셋 */
pci_reset_bus(pdev);
/* Bridge의 Secondary Bus Reset 비트를 설정/해제
 * 하위 버스의 모든 디바이스가 리셋됨 — 다른 디바이스에 영향 주의! */

/* 4. sysfs를 통한 리셋 */
/* echo 1 > /sys/bus/pci/devices/0000:03:00.0/reset */

/* 5. FLR 지원 여부 확인 */
if (pdev->has_flr) {
    pr_info("Device supports FLR\n");
    pcie_flr(pdev);  /* FLR 직접 수행 (100ms 대기 포함) */
}

/* 리셋 후 주의사항:
 * - FLR 후에도 BAR 매핑은 유지되지만, 디바이스 내부 상태는 초기화됨
 * - MSI/MSI-X는 재설정 필요: pci_alloc_irq_vectors() 재호출
 * - Bus Master, Memory Space 비트 재활성화 필요
 * - DMA 매핑은 유효하지만, 디바이스가 DMA를 중단한 상태이므로 재시작 필요
 */

PCI 핫플러그 (Hotplug)

PCIe 디바이스의 런타임 삽입/제거를 지원하는 메커니즘:

# 수동 핫플러그 (sysfs)
# 디바이스 제거
echo 1 > /sys/bus/pci/devices/0000:03:00.0/remove

# 버스 재스캔 (새 디바이스 탐지)
echo 1 > /sys/bus/pci/rescan

# 특정 브릿지 하위만 재스캔
echo 1 > /sys/bus/pci/devices/0000:00:1c.0/rescan

pciehp 드라이버 내부 구현

PCIe Native Hotplug는 drivers/pci/hotplug/pciehp*.c에 구현된 pciehp 드라이버가 담당합니다. Root Port나 Downstream Port의 Slot Capability에 정의된 하드웨어 이벤트를 감지하고 처리합니다.

/* drivers/pci/hotplug/pciehp_ctrl.c — 핫플러그 이벤트 처리 (simplified) */

/* Slot Capability의 인터럽트로 호출되는 워크 핸들러 */
static void pciehp_handle_presence_or_link_change(
    struct controller *ctrl, u32 events)
{
    if (events & PCI_EXP_SLTSTA_PDC) {
        /* Presence Detect Changed — 카드 삽입/제거 감지 */
        bool present = pciehp_card_present(ctrl);
        if (present)
            pciehp_enable_slot(ctrl);   /* 새 디바이스 열거 */
        else
            pciehp_disable_slot(ctrl);  /* 디바이스 제거 처리 */
    }

    if (events & PCI_EXP_SLTSTA_DLLSC) {
        /* Data Link Layer State Changed — 링크 업/다운 */
        bool link_active = pciehp_check_link_active(ctrl);
        if (link_active)
            pciehp_enable_slot(ctrl);
        else
            pciehp_disable_slot(ctrl);
    }
}

/* 디바이스 활성화: 전원 → 링크 → 열거 → 드라이버 바인딩 */
static void pciehp_enable_slot(struct controller *ctrl)
{
    struct pci_bus *parent = ctrl->pcie->port->subordinate;

    /* 1. 슬롯 전원 공급 (Power Controller 지원 시) */
    pciehp_power_on_slot(ctrl);

    /* 2. 링크 훈련(Training) 대기 (최대 1초) */
    pciehp_check_link_status(ctrl);

    /* 3. 하위 버스 디바이스 스캔 + 리소스 할당 */
    pci_lock_rescan_remove();
    pci_scan_slot(parent, PCI_DEVFN(0, 0));
    pci_bus_assign_resources(parent);

    /* 4. 드라이버 매칭 및 probe() 호출 */
    pci_bus_add_devices(parent);
    pci_unlock_rescan_remove();
}

/* 디바이스 비활성화: 드라이버 해제 → 디바이스 제거 → 전원 차단 */
static void pciehp_disable_slot(struct controller *ctrl)
{
    struct pci_bus *parent = ctrl->pcie->port->subordinate;

    pci_lock_rescan_remove();
    /* 하위 모든 디바이스의 remove() 호출 + sysfs 제거 */
    pci_stop_and_remove_bus_device(parent->self);
    pci_unlock_rescan_remove();

    /* 슬롯 전원 차단 */
    pciehp_power_off_slot(ctrl);
}

Slot Capability 레지스터

# Slot Capability 확인
lspci -vvv -s 00:1c.0 | grep -A 15 "Slot\|SltCap\|SltCtl\|SltSta"
# SltCap: AttnBtn+ PwrCtrl+ MRL- AttnInd+ PwrInd+ HotPlug+ Surprise-
#         Slot #1, PowerLimit 75W; Interlock- NoCompl-
# SltCtl: Enable: AttnBtn+ PwrFlt+ MRL- PresDet+ CmdCplt- HPIrq+ LinkChg+
#         Control: AttnInd Off, PwrInd On, Power On, Interlock-
# SltSta: Status: AttnBtn- PowerFlt- MRL- CmdCplt- PresDet+ Interlock-
#         Changed: MRL- PresDet+ LinkState+

Surprise Removal 드라이버 대응

Thunderbolt/USB4 외부 디바이스나 핫스왑(Hot-Swap) 환경에서 사전 알림 없이 디바이스가 제거될 수 있습니다. 드라이버는 이 상황에서 크래시 없이 정상적으로 정리해야 합니다.

/* Surprise Removal에 안전한 PCI 드라이버 패턴 */

static bool mydev_is_removed(struct pci_dev *pdev)
{
    u16 vendor;

    /* Config Space 읽기 — 제거된 디바이스는 0xFFFF 반환 */
    pci_read_config_word(pdev, PCI_VENDOR_ID, &vendor);
    return vendor == (u16)~0;
}

static irqreturn_t mydev_isr(int irq, void *data)
{
    struct mydev_priv *priv = data;
    u32 status;

    /* MMIO 읽기 — 제거 시 0xFFFFFFFF 반환 */
    status = ioread32(priv->regs + MYDEV_INTR_STATUS);
    if (status == ~(u32)0) {
        /* 디바이스 제거 감지 — 인터럽트 폭주(storm) 방지 */
        return IRQ_HANDLED;
    }
    /* 정상 인터럽트 처리 ... */
    return IRQ_HANDLED;
}

static void mydev_remove(struct pci_dev *pdev)
{
    struct mydev_priv *priv = pci_get_drvdata(pdev);

    /* 하드웨어 접근 전에 제거 상태 확인 */
    if (!mydev_is_removed(pdev)) {
        /* 디바이스가 존재하면 정상 종료 시퀀스 */
        mydev_shutdown_hw(priv);
    }

    /* 디바이스 존재 여부와 무관한 정리 (메모리 해제 등) */
    pci_free_irq_vectors(pdev);
    /* pcim_*/devm_* 사용 시 나머지는 자동 해제 */
}

핫플러그 디버깅

# pciehp 디버그 메시지 활성화
echo 'module pciehp +p' > /sys/kernel/debug/dynamic_debug/control
dmesg -w | grep pciehp

# 핫플러그 이벤트 모니터링
udevadm monitor --subsystem-match=pci

# Slot Status 변화 추적
watch -n 1 'lspci -vvv -s 00:1c.0 | grep SltSta'

# Thunderbolt/USB4 핫플러그 확인
dmesg | grep -i "thunderbolt\|usb4"
cat /sys/bus/thunderbolt/devices/*/authorized

PCIe 리셋 종류

PCIe 디바이스를 초기 상태로 되돌리는 여러 리셋 메커니즘이 있습니다. 리셋 범위와 영향이 다르므로 상황에 맞는 리셋을 선택해야 합니다:

/* PCIe 리셋 API 사용 예시 */
#include <linux/pci.h>

/* 1. FLR (Function Level Reset) — 가장 세밀한 리셋 */
int reset_single_function(struct pci_dev *pdev)
{
    int ret;

    /* FLR 지원 여부 확인 */
    if (!pdev->has_flr) {
        dev_warn(&pdev->dev, "FLR not supported\n");
        return -ENOTTY;
    }

    /* FLR 수행: 드라이버 해제 → 리셋 → 100ms 대기 → 복구 */
    ret = pci_reset_function(pdev);
    if (ret)
        dev_err(&pdev->dev, "FLR failed: %d\n", ret);

    /* 리셋 후: Bus Master + Memory Space 재활성화 */
    pci_set_master(pdev);
    return ret;
}

/* 2. SBR (Secondary Bus Reset) — 브릿지 하위 전체 리셋 */
int reset_downstream_bus(struct pci_dev *bridge)
{
    /* 브릿지의 Secondary Bus에 연결된 모든 디바이스 리셋 */
    return pci_reset_bus(bridge);
}

/* 3. 리셋 메서드 우선순위 (커널 내부):
 *    pci_reset_function()은 다음 순서로 시도:
 *    (1) 디바이스 고유 리셋 (dev->reset_fn)
 *    (2) FLR (has_flr 플래그)
 *    (3) AF FLR (Advanced Features)
 *    (4) PM Reset (D3hot → D0 전환)
 *    모두 실패하면 -ENOTTY 반환
 */

VFIO (Virtual Function I/O)

VFIO는 PCI 디바이스를 유저스페이스(또는 VM)에 안전하게 직접 노출하는 프레임워크입니다. IOMMU 기반 격리를 통해 호스트 메모리 보호를 보장합니다.

# VFIO 디바이스 패스스루 설정 (QEMU/KVM)
# 1. 디바이스를 vfio-pci에 바인딩
modprobe vfio-pci
echo "8086 1572" > /sys/bus/pci/drivers/vfio-pci/new_id

# 2. QEMU에서 디바이스 할당
qemu-system-x86_64 \
  -device vfio-pci,host=0000:03:00.0 \
  ...

# IOMMU 그룹 확인
ls -l /sys/bus/pci/devices/0000:03:00.0/iommu_group/devices/

유저스페이스 VFIO 프로그래밍

VFIO API를 사용하면 유저스페이스에서 PCI 디바이스의 Config Space, BAR, 인터럽트, DMA를 직접 제어할 수 있습니다. DPDK, SPDK, QEMU 등이 이 방식으로 고성능 I/O를 구현합니다.

/* VFIO를 이용한 PCI 디바이스 직접 제어 (유저스페이스 C 코드) */
#include <linux/vfio.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <fcntl.h>

int vfio_pci_example(void)
{
    int container, group, device;
    struct vfio_group_status group_status = {
        .argsz = sizeof(group_status)
    };

    /* 1. VFIO 컨테이너 열기 — IOMMU 컨텍스트 관리 */
    container = open("/dev/vfio/vfio", O_RDWR);

    /* 2. IOMMU 그룹 열기 (디바이스의 iommu_group 번호 사용) */
    group = open("/dev/vfio/26", O_RDWR);

    /* 3. 그룹을 컨테이너에 연결 */
    ioctl(group, VFIO_GROUP_SET_CONTAINER, &container);

    /* 4. IOMMU 모델 설정 (Type1 = 페이지 단위 DMA 매핑) */
    ioctl(container, VFIO_SET_IOMMU, VFIO_TYPE1_IOMMU);

    /* 5. 디바이스 FD 획득 */
    device = ioctl(group, VFIO_GROUP_GET_DEVICE_FD,
                   "0000:03:00.0");

    /* ── Config Space 읽기 ── */
    struct vfio_region_info config_info = {
        .argsz = sizeof(config_info),
        .index = VFIO_PCI_CONFIG_REGION_INDEX,
    };
    ioctl(device, VFIO_DEVICE_GET_REGION_INFO, &config_info);

    u16 vendor;
    pread(device, &vendor, 2, config_info.offset + PCI_VENDOR_ID);
    /* vendor == 0x8086 등 */

    /* ── BAR 0 MMIO 매핑 ── */
    struct vfio_region_info bar0_info = {
        .argsz = sizeof(bar0_info),
        .index = VFIO_PCI_BAR0_REGION_INDEX,
    };
    ioctl(device, VFIO_DEVICE_GET_REGION_INFO, &bar0_info);

    void *bar0 = mmap(NULL, bar0_info.size,
        PROT_READ | PROT_WRITE, MAP_SHARED,
        device, bar0_info.offset);
    /* bar0[offset]으로 디바이스 레지스터 직접 접근 */

    /* ── DMA 메모리 매핑 (IOMMU 설정) ── */
    void *dma_buf = mmap(NULL, 4096,
        PROT_READ | PROT_WRITE,
        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

    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)dma_buf,
        .iova  = 0x100000,  /* 디바이스가 볼 DMA 주소 */
        .size  = 4096,
    };
    ioctl(container, VFIO_IOMMU_MAP_DMA, &dma_map);
    /* 이제 디바이스가 IOVA 0x100000으로 DMA 시 dma_buf에 도달 */

    /* ── MSI-X 인터럽트 설정 ── */
    struct vfio_irq_info irq_info = {
        .argsz = sizeof(irq_info),
        .index = VFIO_PCI_MSIX_IRQ_INDEX,
    };
    ioctl(device, VFIO_DEVICE_GET_IRQ_INFO, &irq_info);

    /* eventfd를 벡터 0에 연결 → epoll로 대기 가능 */
    int efd = eventfd(0, EFD_NONBLOCK);
    struct vfio_irq_set *irq_set;
    size_t sz = sizeof(*irq_set) + sizeof(int);
    irq_set = calloc(1, sz);
    irq_set->argsz = sz;
    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 = 1;
    *(int *)irq_set->data = efd;
    ioctl(device, VFIO_DEVICE_SET_IRQS, irq_set);

    /* eventfd로 인터럽트 대기 (epoll 또는 read) */
    uint64_t count;
    read(efd, &count, sizeof(count));
    /* 인터럽트 수신 완료 — 데이터 처리 */

    /* 정리 */
    munmap(bar0, bar0_info.size);
    close(device);
    close(group);
    close(container);
    return 0;
}

P2P DMA (Peer-to-Peer DMA)

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

/* P2P DMA 사용 (커널 5.x+) */
#include <linux/pci-p2pdma.h>

/* P2P 가능 여부 확인 */
if (pci_p2pdma_distance(provider, client, false) < 0)
    return -EOPNOTSUPP;  /* 다른 RC 하위이거나 Switch 미지원 */

/* P2P 메모리 할당 (provider 디바이스의 BAR에서) */
void *p2p_mem = pci_alloc_p2pmem(provider, size);

/* DMA 매핑 (client 디바이스 관점) */
dma_addr_t dma = pci_p2pdma_map_sg(...);

P2P DMA 커널 내부 구현

drivers/pci/p2pdma.c의 P2P DMA 프레임워크는 두 디바이스 간의 토폴로지를 분석하여 P2P 전송 가능 여부를 판단합니다.

/* drivers/pci/p2pdma.c — P2P 거리 계산 (simplified) */

/* 두 디바이스 간 P2P 가능 여부와 거리를 판단 */
int pci_p2pdma_distance(struct pci_dev *provider,
                        struct pci_dev *client,
                        bool verbose)
{
    struct pci_dev *a = provider, *b = client;

    /* 양쪽의 Root Complex까지 상위 경로를 추적 */
    while (a) {
        while (b) {
            if (a == b) {
                /* 공통 조상(common ancestor) 발견
                 * → 같은 Switch/RC 하위 = P2P 가능 */
                return dist;
            }
            if (pci_is_root_bus(b->bus))
                break;
            b = b->bus->self;
        }
        if (pci_is_root_bus(a->bus))
            break;
        a = a->bus->self;
        b = client;
    }
    /* 공통 조상 없음 → 다른 RC 하위 = P2P 불가능
     * (일부 플랫폼은 RC 간 P2P를 호스트 브리지로 라우팅) */
    return -1;
}

NVMe 타겟 P2P DMA 구현 패턴

NVMe-oF(NVMe over Fabrics) 타겟에서 P2P DMA를 활용하면 NVMe SSD 데이터를 시스템 메모리를 거치지 않고 RDMA NIC으로 직접 전송할 수 있습니다.

/* NVMe 타겟 스타일 P2P DMA 패턴 (simplified) */
#include <linux/pci-p2pdma.h>

struct nvmet_req {
    struct pci_dev  *nvme_pdev;   /* NVMe SSD (provider) */
    struct pci_dev  *rdma_pdev;   /* RDMA NIC (client) */
    void           *p2p_buf;
    size_t          len;
};

static int nvmet_p2p_setup(struct nvmet_req *req)
{
    int dist;

    /* 1. P2P 가능 여부 확인 */
    dist = pci_p2pdma_distance(req->nvme_pdev,
                                req->rdma_pdev, true);
    if (dist < 0) {
        pr_warn("P2P not possible, falling back to host memory\n");
        return -EOPNOTSUPP;
    }

    /* 2. P2P 메모리 할당 (NVMe CMB 또는 provider BAR에서) */
    req->p2p_buf = pci_alloc_p2pmem(req->nvme_pdev, req->len);
    if (!req->p2p_buf)
        return -ENOMEM;

    /* 3. SGL/PRP에 P2P 주소 설정
     * → NVMe는 CMB 주소로 읽기 수행
     * → RDMA NIC은 같은 주소로 DMA 읽기하여 네트워크 전송
     * → 시스템 메모리 미경유! */

    return 0;
}

static void nvmet_p2p_cleanup(struct nvmet_req *req)
{
    if (req->p2p_buf)
        pci_free_p2pmem(req->nvme_pdev, req->p2p_buf, req->len);
}

P2P DMA 제약 조건과 호환성

# P2P DMA 지원 확인
cat /sys/bus/pci/devices/0000:03:00.0/p2pmem/size
# 16777216  (16 MB P2P 메모리 사용 가능)

# P2P 가능한 디바이스 쌍 확인 (커널 5.8+)
cat /sys/bus/pci/devices/0000:03:00.0/p2pmem/available

# NVMe CMB 지원 확인
nvme id-ctrl /dev/nvme0 | grep -i cmb
# cmbsz : 0x100 → CMB 지원 (크기: 256 × 4KB = 1 MB)

# NVMe-oF 타겟에서 P2P 활성화
echo 1 > /sys/kernel/config/nvmet/subsystems/nqn/namespaces/1/p2pmem

NTB (Non-Transparent Bridge)

NTB는 두 개의 독립적인 PCIe 계층(hierarchy)을 연결하는 특수 PCIe 브리지로, 양쪽 호스트가 Scratchpad, Doorbell, Memory Window 메커니즘을 통해 데이터를 교환합니다.

CXL (Compute Express Link)

CXL은 PCIe 물리 계층 위에 구축된 인터커넥트로, CPU-디바이스 간 캐시 코히런트 메모리 공유를 지원합니다:

# Linux CXL 서브시스템 (커널 5.18+)
# CXL 디바이스 확인
ls /sys/bus/cxl/devices/

# cxl-cli 도구 (ndctl 패키지)
cxl list                       # CXL 토폴로지 표시
cxl list -M                    # 메모리 디바이스 목록
cxl create-region -t ram ...   # CXL 메모리 리전 생성 → NUMA 노드로 노출

Google TPU (Tensor Processing Unit)

TPU는 Google이 설계한 ASIC 기반 텐서 연산 가속기로, PCIe 또는 자체 인터커넥트(ICI)를 통해 호스트에 연결됩니다. Linux에서는 Gasket/ACCEL 드라이버 프레임워크를 통해 관리합니다.

sysfs 인터페이스

PCI 디바이스 정보는 /sys/bus/pci/ 아래에 노출됩니다:

PCIe Performance 튜닝

PCIe 대역폭을 최대로 활용하려면 TLP 오버헤드를 최소화하고, 흐름 제어 병목(Bottleneck)을 해소해야 합니다. 주요 튜닝 포인트:

MPS / MRRS 최적화

# 현재 MPS/MRRS 확인
lspci -vvv -s 03:00.0 | grep -E "MaxPayload|MaxReadReq"
# DevCap: MaxPayload 512 bytes, PhantFunc 0, Latency L0s <512ns, L1 <1us
# DevCtl: ... MaxPayload 256 bytes, MaxReadReq 512 bytes
# 주의: MaxPayload(DevCtl) ≤ MaxPayload(DevCap)

# MPS 정책 설정 (커널 부팅 파라미터)
pci=pcie_bus_safe        # 링크 경로상 최소 MPS로 설정 (가장 안전)
pci=pcie_bus_perf        # 각 버스 도메인 내 최대 MPS 설정 (성능 우선)
pci=pcie_bus_peer2peer   # 전체 계층에서 최소 MPS (P2P DMA 호환성)

# setpci로 MPS 직접 변경 (주의: 양단 일치 필요)
# DevCtl [7:5] = MPS: 000=128, 001=256, 010=512, 011=1024, 100=2048, 101=4096
setpci -s 03:00.0 CAP_EXP+8.W=0x2820  # MPS=256, MRRS=4096 (예시)

# MRRS 변경 (sysfs)
echo 4096 > /sys/bus/pci/devices/0000:03:00.0/max_read_request_size

Relaxed Ordering / No Snoop

Completion Timeout 튜닝

Non-Posted 요청(MRd, CfgRd/Wr)에 대한 Completion이 일정 시간 내에 도착하지 않으면 Completion Timeout 에러가 발생합니다:

# Completion Timeout 범위 확인
lspci -vvv -s 03:00.0 | grep "CmpltTO"
# DevCap2: Completion Timeout: Range ABC, TimeoutDis+
# DevCtl2: Completion Timeout: 50us to 50ms, TimeoutDis-

# Completion Timeout 비활성화 (디버깅 시)
setpci -s 03:00.0 CAP_EXP+28.W=0x0010  # DevCtl2: Timeout Disable bit

대역폭 실측 및 병목 분석

# 1. 실제 링크 속도/폭 확인
lspci -vvv -s 03:00.0 | grep -E "LnkCap|LnkSta"
# LnkCap: Port #0, Speed 16GT/s (Gen4), Width x16
# LnkSta: Speed 16GT/s (ok), Width x16 (ok)
# 만약 LnkSta가 LnkCap보다 낮으면 → 등화 실패, 물리적 문제 의심

# 2. PCIe 대역폭 계측 (fio NVMe 예시)
fio --name=seqread --ioengine=io_uring --direct=1 --bs=128k \
    --numjobs=4 --iodepth=64 --filename=/dev/nvme0n1 --rw=read \
    --runtime=10 --time_based
# Gen4 x4 NVMe: 이론 ~7.9 GB/s, 실측 ~6.5-7.0 GB/s (→ 82-89% 효율)

# 3. GPU DMA 대역폭 (CUDA bandwidthTest 예시)
# Gen4 x16: 이론 ~31.5 GB/s, H2D 실측 ~25-27 GB/s (→ 79-86% 효율)

# 4. PCIe 성능 카운터 (Intel perf uncore)
perf stat -e uncore_iio_0/event=0x83,umask=0x04/ -a sleep 5
# 플랫폼별 PCIe 카운터로 실시간 대역폭 모니터링

# 5. 병목 진단 체크리스트
# □ LnkSta Speed/Width가 LnkCap과 일치하는가?
# □ MPS가 DevCap 최대값으로 설정되었는가?
# □ MRRS가 충분히 큰가? (DMA 버스트 크기 ≤ MRRS)
# □ AER Correctable Error 카운터가 빠르게 증가하지 않는가?
# □ ASPM이 활성화되어 레이턴시를 유발하지 않는가?
# □ NUMA locality — DMA 버퍼가 PCIe RC와 같은 NUMA 노드에 있는가?
# □ IOMMU 오버헤드 — 패스스루 시 intel_iommu=pt로 바이패스

# 디바이스의 NUMA 노드 확인
cat /sys/bus/pci/devices/0000:03:00.0/numa_node
# 0

# 로컬 CPU 목록 확인
cat /sys/bus/pci/devices/0000:03:00.0/local_cpulist
# 0-15,32-47

# 인터럽트를 로컬 CPU에 바인딩
echo 0-15 > /proc/irq/<IRQ_NUM>/smp_affinity_list

디버깅 도구

lspci

# 기본 디바이스 목록
lspci

# 상세 정보 (-v: verbose, -vv: very verbose)
lspci -vvv -s 03:00.0

# 커널 드라이버 및 모듈 표시
lspci -k

# 트리 구조 (Bus 토폴로지)
lspci -tv

# 숫자 코드 + 이름
lspci -nn

# Configuration Space 16진수 덤프
lspci -xxx -s 03:00.0        # 256 바이트
lspci -xxxx -s 03:00.0       # 4096 바이트 (PCIe 확장)

# Capability 상세 (PCIe Link, MSI-X, AER 등)
lspci -vvv -s 03:00.0 | grep -A 10 "LnkCap\|LnkSta\|MSI-X\|AER"

setpci

# Configuration Space 직접 읽기
setpci -s 03:00.0 VENDOR_ID       # Vendor ID 읽기
setpci -s 03:00.0 04.W            # Command 레지스터 (2바이트)

# Configuration Space 직접 쓰기 (주의!)
setpci -s 03:00.0 04.W=0x0007     # I/O + Memory + Bus Master 활성화

lspci -vvv 출력 완전 해석

실제 lspci -vvv 출력의 핵심 항목을 라인별로 해석합니다. NVMe SSD를 예시로 사용:

## 기본 식별 정보
03:00.0 Non-Volatile memory controller: Samsung Electronics Co Ltd
        NVMe SSD Controller PM9A1 (rev 01)
# 03:00.0 → BDF (Bus:03, Device:00, Function:0)
# Non-Volatile memory controller → Class Code 0x010802
# rev 01 → Revision ID

## Subsystem ID — OEM 변형 식별
        Subsystem: Lenovo Device 5023
# 같은 컨트롤러라도 서브시스템 ID로 노트북/서버 변형 구분

## Control (Command 레지스터의 현재 활성 비트)
        Control: I/O- Mem+ BusMaster+ SpecCycle- MemWINV- ...
# Mem+ → Memory Space 활성 (MMIO BAR 접근 가능)
# BusMaster+ → DMA 활성화 상태
# I/O- → I/O Port 비활성 (NVMe는 MMIO만 사용)

## Status (Status 레지스터)
        Status: Cap+ 66MHz- UDF- FastB2B- ParErr- DEVSEL=fast
                >TAbort- <TAbort- <MAbort- >SERR- <PERR- INTx-
# Cap+ → Capabilities List 있음 (오프셋 34h)
# INTx- → 레거시 인터럽트 비활성 (MSI-X 사용 중)

## BAR 정보
        Region 0: Memory at 6a500000 (64-bit, non-prefetchable) [size=16K]
# BAR0: MMIO, 64-bit, 16 KB (NVMe 레지스터 공간)
# non-prefetchable → 디바이스 레지스터 (side-effect 있음)

## PCIe Capability — 링크 정보 (가장 중요)
        Capabilities: [70] Express (v2) Endpoint, MSI 00
          DevCap: MaxPayload 512 bytes, PhantFunc 0
                  ExtTag+ AttnBtn- AttnInd- PwrInd- RBE+ FLR+ SlotPowerLimit 75W
# MaxPayload 512 → 이 디바이스가 지원하는 최대 MPS (DevCap)
# FLR+ → Function Level Reset 지원

          DevCtl: CorrErr+ NonFatalErr+ FatalErr+ UnsuppReq+
                  RlxdOrd+ ExtTag+ PhantFunc- AuxPwr- NoSnoop+ MaxPayload 256 bytes
                  MaxReadReq 512 bytes
# MaxPayload 256 → 현재 설정된 MPS (DevCap보다 작을 수 있음 — 경로상 최소값)
# MaxReadReq 512 → MRRS 설정값
# RlxdOrd+ → Relaxed Ordering 활성
# NoSnoop+ → No Snoop 활성

          LnkCap: Port #0, Speed 16GT/s (Gen4), Width x4
                  ASPM L1, Exit Latency L1 <64us
                  ClockPM+ Surprise- LLActRep- BwNot- ASPMOptComp+
# Speed 16GT/s, Width x4 → 디바이스의 최대 링크 능력
# ASPM L1 → L1만 지원 (L0s 미지원)

          LnkSta: Speed 16GT/s (ok), Width x4 (ok)
                  TrErr- Train- SlotClk+ DLActive- BWMgmt- ABWMgmt-
# ★ Speed/Width가 LnkCap과 일치 → 링크 정상
# 불일치 시 → 등화 실패, PCB 문제, 슬롯 문제 의심

## MSI-X Capability
        Capabilities: [b0] MSI-X: Enable+ Count=128 Masked-
                  Vector table: BAR=0 offset=00002000
                  PBA: BAR=0 offset=00003000
# MSI-X Enable+ → 현재 MSI-X 활성 상태
# Count=128 → 최대 128개 벡터 (NVMe: QP당 1벡터)
# Vector table @ BAR0+0x2000, PBA @ BAR0+0x3000

## L1 PM Substates (확장 Capability)
        Capabilities: [900 v1] L1 PM Substates
          L1SubCap: PCI-PM_L1.2+ PCI-PM_L1.1+ ASPM_L1.2+ ASPM_L1.1+
                    PortCommonModeRestoreTime=60us PortTPowerOnTime=10us
          L1SubCtl1: PCI-PM_L1.2+ PCI-PM_L1.1+ ASPM_L1.2+ ASPM_L1.1+
                     T_CommonMode=0us LTR1.2_Threshold=163840ns
# L1.2 ASPM 활성 → 가장 깊은 절전 (레퍼런스 클럭까지 차단)
# PortTPowerOnTime=10us → L1.2→L0 복귀에 10µs 소요

## Kernel driver/module
        Kernel driver in use: nvme
        Kernel modules: nvme
# 현재 바인딩된 커널 드라이버

커널 디버깅

# PCI 관련 커널 메시지
dmesg | grep -i pci

# PCI 리소스 할당 정보
cat /proc/iomem | grep -i pci
cat /proc/ioports | grep -i pci

# PCIe 링크 속도/폭 모니터링
cat /sys/bus/pci/devices/0000:03:00.0/current_link_speed
cat /sys/bus/pci/devices/0000:03:00.0/current_link_width

# AER 에러 카운터
cat /sys/bus/pci/devices/0000:03:00.0/aer_dev_correctable
cat /sys/bus/pci/devices/0000:03:00.0/aer_dev_nonfatal
cat /sys/bus/pci/devices/0000:03:00.0/aer_dev_fatal

# FLR (Function Level Reset)
echo 1 > /sys/bus/pci/devices/0000:03:00.0/reset

# 커널 Dynamic Debug
echo 'module pci +p' > /sys/kernel/debug/dynamic_debug/control
echo 'module pcieport +p' > /sys/kernel/debug/dynamic_debug/control

lspci -tv 출력 예시

PCIe 트레이스포인트

# 사용 가능한 PCI 트레이스포인트 목록
ls /sys/kernel/debug/tracing/events/pci/
# pci_bus_read_config, pci_bus_write_config

# AER 트레이스포인트
ls /sys/kernel/debug/tracing/events/ras/
# aer_event

# Config Space 접근 추적 (디버깅/성능 분석)
echo 1 > /sys/kernel/debug/tracing/events/pci/pci_bus_read_config/enable
echo 1 > /sys/kernel/debug/tracing/events/pci/pci_bus_write_config/enable
cat /sys/kernel/debug/tracing/trace_pipe
# nvme-0      [003] .... 12345.678: pci_bus_read_config: 03:00.0 read 2 bytes @ 4 = 0x0006

# AER 이벤트 모니터링
echo 1 > /sys/kernel/debug/tracing/events/ras/aer_event/enable
cat /sys/kernel/debug/tracing/trace_pipe
# aer_event: 0000:03:00.0 PCIe Bus Error: severity=Corrected, type=Data Link Layer ...

# trace-cmd를 이용한 기록
trace-cmd record -e pci -e ras sleep 10
trace-cmd report | less

# PCIe Port Service 드라이버 상태
lspci -vvv -s 00:1c.0 | grep "Kernel driver"
# Kernel driver in use: pcieport
# pcieport 드라이버가 AER, DPC, Hotplug, PME, Bandwidth Notification 서비스 담당
ls /sys/bus/pci/drivers/pcieport/
# 0000:00:01.0 0000:00:1c.0 ... (Root Port / Switch Port 목록)

자주 발생하는 PCIe 문제와 진단

커널 소스 구조

주요 Kconfig 옵션

참고자료

커널 공식 문서

• Linux PCI 문서 인덱스 — PCI 관련 커널 문서 모음
• How To Write Linux PCI Drivers — PCI 드라이버 작성 가이드
• MSI/MSI-X HOWTO — MSI/MSI-X 인터럽트 설정 가이드
• PCI sysfs 인터페이스 — sysfs를 통한 PCI 디바이스 접근
• PCI Express Port Bus Driver — PCIe 포트 버스 드라이버 가이드
• PCI SR-IOV HOWTO — SR-IOV 설정 및 사용 가이드
• ACPI & PCI Host Bridge — ACPI 기반 PCI 호스트 브리지 정보

커널 소스 코드

• drivers/pci/pci.c — PCI 코어 구현
• drivers/pci/pci-driver.c — PCI 드라이버 등록/매칭
• drivers/pci/probe.c — PCI 디바이스 열거(enumeration)
• drivers/pci/msi/msi.c — MSI/MSI-X 구현
• drivers/pci/iov.c — SR-IOV 구현
• include/linux/pci.h — pci_dev, pci_driver 정의
• include/uapi/linux/pci_regs.h — PCI 레지스터 상수
• drivers/pci/pcie/ — PCIe 서비스 (AER, PME, hotplug)

규격 문서

• PCI-SIG 공식 규격 — PCI/PCIe 공식 표준 규격 목록
• PCIe Base Specification — PCIe 기본 규격 문서

외부 자료

• An introduction to PCI device assignment with VFIO — LWN, VFIO를 통한 PCI 디바이스 할당 소개
• How to access PCI device resources through sysfs — LWN, sysfs를 통한 PCI 리소스 접근
• OSDev PCI 위키 — PCI 하드웨어 및 프로그래밍 기초

관련 문서

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

• SR-IOV — PF/VF 드라이버, VFIO VM 패스스루
• NTB (Non-Transparent Bridge) — 멀티호스트 PCIe 인터커넥트
• Google TPU — MXU/HBM, Gasket/ACCEL 드라이버
• 디바이스 드라이버 — PCI 드라이버 작성
• DMA — PCI DMA 매핑
• IOMMU — PCI 디바이스 격리와 주소 변환
• VFIO & mdev — PCI 패스스루와 가상화
• 인터럽트 — PCI MSI/MSI-X
• CXL 메모리 — PCIe 기반 캐시 코히런트 인터커넥트