x86_64 명령어셋 레퍼런스

x86_64(AMD64/Intel 64) 아키텍처의 명령어를 AT&T 문법 기준으로 종합 정리합니다. CISC 설계 철학과 가변 길이 인코딩, 16개 범용 레지스터(Register)와 RFLAGS, SSE/AVX/AVX-512 SIMD 레지스터, 주소 지정 모드, 데이터 전송·산술·논리·분기·스택·시스템·원자적(Atomic)·SIMD 명령어 카테고리 표, REX/VEX/EVEX 인코딩 다이어그램, 커널 핵심 명령어(SYSCALL, SWAPGS, LOCK CMPXCHG, INVLPG) 고급까지 Linux 커널 개발에 필요한 x86_64 ISA 전체를 다룹니다.

아키텍처 개요

x86_64(AMD64)는 2003년 AMD가 IA-32(x86)를 64-bit로 확장한 CISC 아키텍처입니다. 8086(1978) → 80386(1985, 32-bit) → AMD64(2003, 64-bit) 순으로 발전했으며, 하위 호환성을 유지하면서 레지스터와 주소 공간(Address Space)을 확장했습니다.

동작 모드 전환 다이어그램

x86_64 프로세서는 전원 인가 후 Real Mode에서 시작하며, 제어 레지스터 비트를 조작해 단계적으로 Long Mode(64-bit)까지 전환합니다. 리눅스 커널 부트 과정에서 이 전환은 arch/x86/boot/compressed/head_64.S에서 수행됩니다.

레지스터 셋

범용 레지스터 (64-bit / 32-bit / 16-bit / 8-bit)

레지스터 중첩 구조 (RAX 예시)

x86_64 범용 레지스터는 하위 호환성을 위해 중첩 구조를 가집니다. 64-bit RAX 안에 32-bit EAX가, 그 안에 16-bit AX가, AX는 다시 상위 AH와 하위 AL로 나뉩니다.

RFLAGS 레지스터 주요 비트

특수/시스템 레지스터

SIMD 레지스터

SIMD 레지스터 중첩 구조

SIMD 레지스터는 SSE → AVX → AVX-512 확장에 따라 중첩 구조를 가집니다. ZMM의 하위 256-bit은 YMM이고, YMM의 하위 128-bit은 XMM입니다.

주소 지정 모드

x86_64 AT&T 문법에서 메모리 피연산자는 displacement(base, index, scale) 형식을 사용합니다.

ModR/M 및 SIB 바이트 구조

x86_64 메모리 피연산자의 인코딩에서 ModR/M 바이트는 주소 모드와 레지스터를 지정하고, SIB(Scale-Index-Base) 바이트는 복합 주소 계산(base + index * scale + displacement)을 인코딩합니다. ModR/M의 R/M 필드가 100(RSP 인코딩)이면 SIB 바이트가 뒤따릅니다.

데이터 전송 명령어

/* 커널에서 자주 보이는 패턴 */

/* 1. LEA로 구조체 멤버 주소 계산 (메모리 접근 없음) */
/*    leaq offset(%rdi), %rax   — container_of() 매크로 결과 */

/* 2. MOVSX: syscall 번호(int) → 테이블 인덱스(long) */
/*    movslq %eax, %rax  — 32-bit 부호 있는 값을 64-bit로 확장 */

/* 3. MOVZX: 바이트 읽기 → 레지스터 제로 확장 */
/*    movzbl (%rdi), %eax  — 1바이트 로드, EAX 제로 확장 (RAX 상위도 0) */

/* 4. CMOVcc: 조건부 이동으로 분기 제거 */
int clamp_min(int val, int min_val) {
    return val < min_val ? min_val : val;
    /* 컴파일 결과:
       cmpl %esi, %edi      // val - min_val
       cmovll %esi, %edi    // val < min_val이면 edi = min_val
       movl %edi, %eax      // return
    */
}

산술 명령어

/* GCC가 자주 생성하는 LEA 패턴 */

/* x * 3 */
leaq    (%rdi,%rdi,2), %rax    /* rax = rdi + rdi*2 = rdi*3 */

/* x * 5 + 1 */
leaq    1(%rdi,%rdi,4), %rax   /* rax = rdi + rdi*4 + 1 = rdi*5 + 1 */

/* x * 12 (두 단계) */
leaq    (%rdi,%rdi,2), %rax    /* rax = rdi*3 */
shlq    $2, %rax               /* rax = rdi*3*4 = rdi*12 */

/* 주의: LEA는 RFLAGS를 변경하지 않으므로 */
/* CMP/TEST 뒤의 조건 분기를 방해하지 않음 */
cmpq    $0, %rsi
leaq    1(%rdi), %rdi          /* rdi++, 플래그 보존 (INC는 ZF 변경) */
je      .Lzero                  /* 위의 CMP 결과로 분기 */

논리/시프트/비트 조작 명령어

비교/분기 명령어

분기 예측(Branch Prediction)과 커널 최적화

현대 x86_64 프로세서는 분기 예측 유닛(BPU)을 사용해 조건 분기의 결과를 투기적으로 예측합니다. 예측이 맞으면 파이프라인(Pipeline)이 지연(Latency) 없이 계속 진행되지만, 예측 실패(misprediction) 시 10~20 사이클의 페널티가 발생합니다.

/* include/linux/compiler.h */
#define likely(x)   __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)

/* 사용 예시 — 페이지 폴트 핸들러 */
if (unlikely(fault_signal_pending(fault, regs))) {
    /* 시그널 처리 (cold path — 거의 실행되지 않음) */
    return;
}
/* 정상 처리 (hot path — 대부분 여기로 진행) */

/* unlikely() 적용 시 GCC가 생성하는 코드 레이아웃 */
/* hot path가 직선(fall-through)이 되도록 배치 */

.Lhot_path:
    testq   %rax, %rax
    jne     .Lcold_path         /* unlikely: 분기 안 하는 것이 일반적 */
    /* ... 정상 처리 (fall-through) ... */
    ret

    /* cold path는 함수 끝으로 분리 (I-cache 효율) */
    .section .text.unlikely
.Lcold_path:
    /* ... 에러 처리 ... */
    jmp     .Lerror_handler

스택/함수 호출 명령어

시스템/특권 명령어

SYSCALL/SYSRET 메커니즘 상세

SYSCALL은 인터럽트(INT 0x80)보다 훨씬 빠른 시스템 콜 진입 방법입니다. 스택 전환이나 IDT 조회 없이 MSR에 미리 설정된 값으로 즉시 커널 코드로 점프합니다. 이 과정에서 하드웨어가 자동으로 수행하는 레지스터 조작을 이해하는 것이 중요합니다.

원자적/동기화 명령어

LOCK 접두사는 다음 명령어의 메모리 연산을 원자적으로 만듭니다. 캐시 라인 락 또는 버스(Bus) 락을 통해 멀티코어 환경에서 원자성을 보장합니다.

LOCK CMPXCHG 패턴 (Compare-And-Swap)

/* atomic_cmpxchg: [rdi]가 rsi이면 rdx로 교체 */
atomic_cmpxchg:
    movq    %rsi, %rax          /* RAX ← expected (old) */
    lock cmpxchgq %rdx, (%rdi) /* if [RDI]==RAX then [RDI]←RDX */
                                  /* RAX ← [RDI] (이전 값) */
    ret                         /* RAX에 이전 값 반환 */

XCHG 기반 스핀락(Spinlock) 구현

XCHG는 메모리 피연산자와 사용될 때 암묵적으로 LOCK이 적용됩니다. 이 특성을 이용한 스핀락은 가장 기본적인 커널 동기화 방식입니다.

/* 단순 스핀락 구현 (Test-and-Set) */
/* RDI = lock 주소, lock=0 (해제), lock=1 (획득) */

spin_lock:
    movl    $1, %eax
.Lretry:
    xchgl   %eax, (%rdi)          /* 원자적 교환 (암묵적 LOCK) */
    testl   %eax, %eax             /* 이전 값이 0이었으면 → 락 획득 성공 */
    jnz     .Lspin                  /* 아니면 스핀 */
    ret

.Lspin:
    pause                           /* 스핀 루프 힌트 (전력 절감 + 파이프라인) */
    cmpl    $0, (%rdi)              /* Test: 락이 해제되었는지 읽기만 (LOCK 없이) */
    jne     .Lspin                  /* 아직 잠겨있으면 계속 스핀 */
    jmp     .Lretry                 /* 해제된 것 같으면 Set 재시도 */

spin_unlock:
    movl    $0, (%rdi)              /* 단순 쓰기 (x86 스토어 순서 보장) */
    ret

XADD 기반 참조 카운팅

LOCK XADD는 원자적으로 값을 더하면서 이전 값을 반환합니다. 이는 참조 카운팅에서 이전 카운트 확인이 필요할 때 핵심적으로 사용됩니다.

/* 커널 refcount 감소 (arch/x86/include/asm/refcount.h 기반) */
static inline bool refcount_dec_and_test(refcount_t *r)
{
    int val = -1;  /* 감소할 값 */

    asm volatile(LOCK_PREFIX "xaddl %0, %1"
                 : "+r"(val), "+m"(r->refs.counter)
                 :: "memory");

    /* val = 이전 값, counter는 이미 감소됨 */
    /* 이전 값이 1이었으면 → 감소 후 0 → 마지막 참조 해제 */
    return val == 1;
}

/* 사용 패턴 */
if (refcount_dec_and_test(&obj->refcnt)) {
    /* 참조 카운트 0 → 객체 해제 */
    kfree(obj);
}

SIMD/벡터 명령어

SSE 명령어 (128-bit XMM)

AVX 명령어 (256-bit YMM)

AVX-512 명령어 (512-bit ZMM)

커널 핵심 명령어

SYSCALL/SYSRET 진입 경로

x86_64 Linux에서 시스템 콜은 SYSCALL 명령어로 진입합니다. MSR_LSTAR에 저장된 entry_SYSCALL_64 주소로 점프합니다.

/* arch/x86/entry/entry_64.S — entry_SYSCALL_64 핵심 경로 */
entry_SYSCALL_64:
    swapgs                       /* GS를 커널 per-cpu로 교환 */
    movq    %rsp, PER_CPU_VAR(cpu_tss_rw + TSS_sp2)
    movq    PER_CPU_VAR(cpu_current_top_of_stack), %rsp
    /* pt_regs 구조체 저장 */
    pushq   $__USER_DS            /* SS */
    pushq   PER_CPU_VAR(cpu_tss_rw + TSS_sp2) /* RSP */
    pushq   %r11                    /* RFLAGS (SYSCALL이 R11에 저장) */
    pushq   $__USER_CS              /* CS */
    pushq   %rcx                    /* RIP (SYSCALL이 RCX에 저장) */
    pushq   %rax                    /* syscall 번호 */
    /* ... 나머지 레지스터 저장, 시스콜 디스패치 ... */

컨텍스트 전환 시 레지스터 저장/복원

시스템 콜이나 인터럽트로 커널에 진입할 때, 하드웨어와 소프트웨어가 역할을 분담하여 사용자 레지스터를 저장합니다. SYSCALL은 최소한의 레지스터만 하드웨어가 저장하고, 나머지는 커널 진입 코드(entry_SYSCALL_64)가 수동으로 저장합니다.

SWAPGS와 per-cpu 데이터 접근 패턴

SWAPGS는 GS 베이스 레지스터와 MSR_KERNEL_GS_BASE를 교환합니다. 커널 진입 시 per-cpu 데이터 접근을 위해 사용되며, 복귀 시 다시 교환합니다. GS 베이스를 통해 현재 CPU의 per-cpu 영역에 빠르게 접근할 수 있습니다.

/* SWAPGS + per-cpu 접근 패턴 */

/* 1. 커널 진입 시: GS를 커널 per-cpu 영역으로 교환 */
/*    SWAPGS → GS.base = 현재 CPU의 per-cpu 오프셋 */

/* 2. per-cpu 변수 접근 (GS 세그먼트 오버라이드) */
/*    movq %gs:offset, %rax  — per-cpu 변수 읽기 */

/* arch/x86/include/asm/percpu.h — 간략화 */
#define this_cpu_read_8(pcp) ({                           \
    u64 val;                                               \
    asm volatile("movq %%gs:%1, %0"                       \
                 : "=r"(val)                               \
                 : "m"(pcp));                               \
    val;                                                     \
})

/* 사용 예: 현재 CPU의 current task 가져오기 */
static inline struct task_struct *get_current(void)
{
    return this_cpu_read_8(current_task);
    /* 컴파일 결과: movq %gs:current_task, %rax */
}

/* 3. 커널 복귀 시: SWAPGS로 GS를 사용자 공간 값으로 복원 */
/*    SWAPGS → GS.base = 사용자 프로세스의 GS (TLS 등) */

LOCK CMPXCHG — 커널 atomic_cmpxchg

/* arch/x86/include/asm/cmpxchg.h — 간략화 */
static inline u64 __cmpxchg(volatile void *ptr, u64 old, u64 new)
{
    u64 prev;
    asm volatile(LOCK_PREFIX "cmpxchgq %2, %1"
                 : "=a"(prev), "+m"(*(volatile u64 *)ptr)
                 : "r"(new), "0"(old)
                 : "memory");
    return prev;
}

INVLPG — TLB 무효화

/* 단일 페이지 TLB 엔트리 무효화 */
static inline void __invlpg(unsigned long addr)
{
    asm volatile("invlpg (%0)" :: "r"(addr) : "memory");
}

WRMSR/RDMSR — MSR 접근

static inline void wrmsr(u32 msr, u32 low, u32 high)
{
    asm volatile("wrmsr"
                 :: "c"(msr), "a"(low), "d"(high)
                 : "memory");
}

명령어 인코딩

x86_64 명령어는 가변 길이로, 최대 15바이트까지 가능합니다. 레거시 접두사, REX, VEX, EVEX 네 가지 인코딩 체계가 있습니다.

인코딩 실전 예제

실제 명령어가 어떻게 바이트로 인코딩되는지 두 가지 예제를 통해 살펴봅니다.

최근 아키텍처 확장 (v6.14+)

Intel APX — Advanced Performance Extensions (v6.16+)

커널 6.16에서 Intel APX(Advanced Performance Extensions) 지원이 추가되었습니다. APX는 x86-64의 주요 한계를 해소하는 ISA 확장으로, 다음과 같은 핵심 기능을 제공합니다:

4096 CPU 코어 지원 (v6.14+)

커널 6.14에서 x86_64의 최대 CPU 코어 수 제한이 2048에서 4096으로 확장되었습니다 (CONFIG_NR_CPUS 최댓값 증가). 이는 AMD EPYC/Intel Xeon의 고코어 서버와 멀티소켓 시스템의 확장성을 지원합니다.

시스템 레지스터

x86-64의 시스템 레지스터는 CPU 모드 전환, 페이징, 디버깅, 성능 모니터링 등 커널 동작의 핵심을 제어합니다. Control Register(CR0-CR4), Debug Register(DR0-DR7), MSR(Model-Specific Register)의 비트 필드를 정확히 이해해야 커널 초기화 코드와 예외 처리를 분석할 수 있습니다.

디버그 레지스터 (DR0-DR7)

/* DR7 비트 필드 */
/* bit 0,2,4,6 (L0-L3): 로컬 BP 활성화 */
/* bit 1,3,5,7 (G0-G3): 글로벌 BP 활성화 */
/* bit 16-17 (R/W0): DR0 조건 (00=실행, 01=쓰기, 10=I/O, 11=읽기/쓰기) */
/* bit 18-19 (LEN0): DR0 길이 (00=1B, 01=2B, 10=8B, 11=4B) */
/* bit 20-23: DR1 조건/길이, bit 24-27: DR2, bit 28-31: DR3 */

/* 커널 hw_breakpoint 사용 예 */
/* perf_event_create_kernel_counter() → arch_install_hw_breakpoint() */
/* → set_debugreg(addr, 0)  // DR0에 주소 설정 */
/* → set_debugreg(ctrl, 7)  // DR7에 조건 설정 */

성능 모니터링 카운터 (PMC)

/* PERFEVTSELx 비트 필드 */
/* bit 0-7   : EventSelect (이벤트 코드) */
/* bit 8-15  : UMask (이벤트 세분류) */
/* bit 16    : USR (유저 모드 카운트) */
/* bit 17    : OS (커널 모드 카운트) */
/* bit 20    : INT (오버플로 시 인터럽트/NMI) */
/* bit 22    : EN (카운터 활성화) */
/* bit 23    : INV (조건 반전) */
/* bit 24-31 : CMASK (카운트 마스크) */

/* 커널 perf 서브시스템 사용 흐름 */
/* perf_event_open() → x86_pmu_hw_config() */
/* → wrmsrl(MSR_P6_EVNTSEL0, config) → wrmsrl(MSR_P6_PERFCTR0, 0) */
/* 카운터 오버플로 → NMI → intel_pmu_handle_irq() → 샘플 저장 */

가상화(Virtualization) 확장 (VMX) 레지스터

SIMD/벡터 확장

x86-64의 SIMD 확장은 SSE → AVX → AVX-512 → AMX로 발전해왔습니다. 커널은 암호화(AES-NI), 체크섬(CRC32c), RAID(XOR/P+Q), 문자열 연산에서 SIMD를 활용합니다. 각 세대의 레지스터 폭, 명령어 형식, 커널 사용 패턴을 이해해야 합니다.

System V AMD64 ABI 호출 규약

System V AMD64 ABI는 리눅스, BSD, macOS 등 대부분의 Unix 계열 운영체제에서 사용하는 x86_64 호출 규약입니다. 커널과 유저 공간 모두 이 ABI를 따르며, 함수 인자 전달, 반환값, 스택 정렬, callee-saved 레지스터 규칙을 정의합니다.

레지스터 할당 다이어그램

System V AMD64 ABI에서 정수 인자 6개와 부동소수점 인자 8개는 레지스터로 전달되고, 초과분은 스택에 push됩니다. 반환값은 RAX(정수)와 XMM0(부동소수점)을 사용합니다.

C → 어셈블리 매핑(Mapping)

C 함수와 그에 대응하는 어셈블리 코드를 비교하면 ABI 규약이 어떻게 적용되는지 명확히 보입니다.

/* C 소스 */
long example(long a, long b, long c, long d, long e, long f) {
    return a + b + c + d + e + f;
}

/* GCC -O2 출력 (AT&T 문법) */
example:
    leaq    (%rdi,%rsi), %rax    # a(RDI) + b(RSI) → RAX
    addq    %rdx, %rax           # + c(RDX)
    addq    %rcx, %rax           # + d(RCX)
    addq    %r8, %rax            # + e(R8)
    addq    %r9, %rax            # + f(R9)
    retq                         # RAX에 결과 반환

Red Zone 사용 예

리프 함수(다른 함수를 호출하지 않는 함수)는 Red Zone을 활용해 RSP 조정 없이 로컬 변수를 저장할 수 있습니다. 커널에서는 -mno-red-zone으로 비활성화합니다.

/* Red Zone을 사용하는 리프 함수 (유저 공간) */
leaf_func:
    # RSP를 조정하지 않고 Red Zone에 저장
    movq    %rbx, -8(%rsp)     # callee-saved 백업 (Red Zone)
    movq    %rdi, %rbx           # 인자를 RBX에 저장
    movq    %rbx, %rax           # 반환값 설정
    movq    -8(%rsp), %rbx     # callee-saved 복원
    retq

/* 커널에서는 인터럽트가 RSP 아래를 덮어쓰므로
   arch/x86/Makefile: KBUILD_CFLAGS += -mno-red-zone */

16-byte 스택 정렬

ABI는 CALL 직전에 RSP가 16-byte 경계에 정렬되어야 합니다. SSE 명령어(MOVAPS 등)는 정렬되지 않은 접근 시 #GP 예외를 발생시킵니다.

/* 스택 정렬 예시: 7개 인자 함수 호출 */
caller:
    subq    $8, %rsp           # 16-byte 정렬 패딩
    pushq   $42                 # 7번째 인자 (스택)
    movq    $6, %r9            # 6번째 인자
    movq    $5, %r8            # 5번째 인자
    movq    $4, %rcx           # 4번째 인자
    movq    $3, %rdx           # 3번째 인자
    movq    $2, %rsi           # 2번째 인자
    movq    $1, %rdi           # 1번째 인자
    callq   target_func        # CALL이 return addr push → RSP ≡ 0 mod 16
    addq    $16, %rsp          # 스택 정리 (8 패딩 + 8 인자)
    retq

4/5-레벨 페이징 워크

x86_64의 가상 주소 변환은 CR3 레지스터에서 시작하여 계층적 페이지 테이블을 순회합니다. 기본 4-레벨 페이징은 48-bit 가상 주소(256TB)를 지원하며, 5-레벨 페이징(LA57)은 57-bit 가상 주소(128PB)까지 확장합니다.

4/5-레벨 페이징 워크 다이어그램

가상 주소의 각 9-bit 필드가 해당 테이블의 인덱스로 사용되어, CR3에서 최종 물리 주소까지 단계적으로 변환됩니다.

CR3 레지스터 포맷

CR3은 최상위 페이지 테이블의 물리 주소를 가리키며, PCID(Process Context ID)를 포함하여 TLB 플러시를 최적화합니다.

/* CR3 레지스터 포맷 (PCID 활성 시) */
/*
 * Bit 63:    PCID 무효화 제어 (INVPCID)
 *            0 = CR3 로드 시 PCID에 해당하는 TLB 엔트리 무효화
 *            1 = TLB 무효화 생략 (noflush)
 * Bit 62:12  PML4/PML5 물리 주소 (4KB 정렬)
 * Bit 11:0   PCID (12-bit, 최대 4096 프로세스 구분)
 */

/* arch/x86/include/asm/tlbflush.h */
#define X86_CR3_PCID_NOFLUSH   (1UL << 63)  /* TLB 무효화 생략 */
#define X86_CR3_PCID_MASK      0xFFF           /* PCID 12-bit */

/* KPTI: 커널/유저 페이지 테이블 분리 시 CR3 전환 */
/* 유저 PGD = 커널 PGD + PAGE_SIZE (연속 배치) */
#define PTI_USER_PGTABLE_BIT   PAGE_SHIFT
#define PTI_USER_PGTABLE_MASK  (1 << PTI_USER_PGTABLE_BIT)

커널 페이지 테이블 매크로

커널은 5단계 추상화 매크로를 사용하여 4-레벨과 5-레벨 페이징을 통합 관리합니다. 4-레벨 시스템에서는 p4d 레벨이 fold되어 PGD와 동일하게 동작합니다.

/* arch/x86/include/asm/pgtable.h — 페이지 테이블 워크 매크로 */

/* 1단계: PGD (= PML5 or PML4) */
pgd_t *pgd = pgd_offset(mm, addr);     /* mm→pgd + pgd_index(addr) */

/* 2단계: P4D (5-레벨에서만 실제 테이블, 4-레벨에서는 fold) */
p4d_t *p4d = p4d_offset(pgd, addr);     /* 4-레벨: (p4d_t *)pgd */

/* 3단계: PUD (= PDPT) */
pud_t *pud = pud_offset(p4d, addr);     /* p4d_page_vaddr(*p4d) + pud_index(addr) */

/* 4단계: PMD (= PD) */
pmd_t *pmd = pmd_offset(pud, addr);     /* pud_page_vaddr(*pud) + pmd_index(addr) */

/* 5단계: PTE (= PT entry) */
pte_t *pte = pte_offset_kernel(pmd, addr);

/* Huge page 확인 */
if (pud_large(*pud))    /* 1GB huge page (PS 비트) */
if (pmd_large(*pmd))    /* 2MB huge page (PS 비트) */

/* 5-레벨 감지 */
if (pgtable_l5_enabled())
    /* CR4.LA57 = 1, PML5 활성 */

커널 어셈블리 실전 예제

리눅스 커널은 성능이 중요하거나 하드웨어 접근이 필요한 경로에서 직접 어셈블리를 사용합니다. 시스템 콜 진입점(Entry Point), 컨텍스트 전환, 원자적 연산(Atomic Operation), 유저 공간 데이터 복사 등이 대표적입니다.

시스템 콜 진입점 (entry_SYSCALL_64)

SYSCALL 명령어가 실행되면 프로세서는 Ring 0으로 전환하고 LSTAR MSR이 가리키는 entry_SYSCALL_64로 점프합니다. 이 코드는 유저 레지스터를 저장하고 커널 스택으로 전환합니다.

/* arch/x86/entry/entry_64.S — 시스템 콜 진입 */
SYM_CODE_START(entry_SYSCALL_64)
    swapgs                               # GS 베이스를 커널 per-CPU로 전환
    movq    %rsp, PER_CPU_VAR(cpu_tss_rw + TSS_sp2)
                                          # 유저 RSP를 TSS에 임시 저장
    SWITCH_TO_KERNEL_CR3 scratch_reg=%rsp # KPTI: 커널 페이지 테이블로 전환
    movq    PER_CPU_VAR(pcpu_hot + X86_top_of_stack), %rsp
                                          # 커널 스택 포인터 로드

    /* pt_regs 구조체에 레지스터 저장 */
    pushq   $__USER_DS                    # pt_regs→ss
    pushq   PER_CPU_VAR(cpu_tss_rw + TSS_sp2)  # pt_regs→sp (유저 RSP)
    pushq   %r11                          # pt_regs→flags (SYSCALL이 저장한 RFLAGS)
    pushq   $__USER_CS                    # pt_regs→cs
    pushq   %rcx                          # pt_regs→ip (SYSCALL이 저장한 RIP)
    pushq   %rax                          # pt_regs→orig_ax (시스템 콜 번호)

    PUSH_AND_CLEAR_REGS rax=$-ENOSYS     # 나머지 레지스터 저장 + 클리어
    movq    %rsp, %rdi                    # pt_regs 포인터를 1번째 인자로
    callq   do_syscall_64                # C 핸들러 호출

컨텍스트 전환 (__switch_to_asm)

스케줄러(Scheduler)가 태스크(Task)를 전환할 때 callee-saved 레지스터와 스택 포인터를 교체합니다.

/* arch/x86/entry/entry_64.S — 컨텍스트 전환 */
SYM_FUNC_START(__switch_to_asm)
    /* callee-saved 레지스터 저장 (prev 태스크) */
    pushq   %rbp
    pushq   %rbx
    pushq   %r12
    pushq   %r13
    pushq   %r14
    pushq   %r15

    /* 스택 포인터 교체 */
    movq    %rsp, TASK_threadsp(%rdi)     # prev→thread.sp = RSP
    movq    TASK_threadsp(%rsi), %rsp     # RSP = next→thread.sp

    /* STACKLEAK: 스택 카나리 포이즌 */
#ifdef CONFIG_STACKPROTECTOR
    movq    TASK_stack_canary(%rsi), %rbx
    movq    %rbx, PER_CPU_VAR(fixed_percpu_data) + FIXED_stack_canary
#endif

    /* callee-saved 레지스터 복원 (next 태스크) */
    popq    %r15
    popq    %r14
    popq    %r13
    popq    %r12
    popq    %rbx
    popq    %rbp
    jmp     __switch_to                  # C 함수로 FPU, TLS 등 나머지 전환
SYM_FUNC_END(__switch_to_asm)

LOCK CMPXCHG 원자적 연산

커널의 atomic_cmpxchg()는 LOCK CMPXCHG로 구현되어 멀티코어 환경에서 원자적 비교-교환을 수행합니다.

/* arch/x86/include/asm/cmpxchg.h — atomic compare-and-exchange */
/*
 * CMPXCHG: if (*ptr == old) { *ptr = new; ZF=1; } else { EAX = *ptr; ZF=0; }
 * LOCK 접두사: 버스 락/캐시 락으로 원자성 보장
 */
static __always_inline unsigned long
__cmpxchg(volatile void *ptr, unsigned long old, unsigned long new, int size)
{
    unsigned long prev;
    switch (size) {
    case 8:
        asm volatile("lock; cmpxchgq %1, %2"
                     : "=a"(prev)                /* output: RAX = prev */
                     : "r"(new), "m"(*((u64 *)ptr)),
                       "0"(old)                  /* input: RAX = old */
                     : "memory");
        return prev;
    }
}

copy_user_generic 유저 메모리 복사

유저 공간 데이터를 커널로 복사할 때는 페이지 폴트(Page Fault)가 발생할 수 있어 _ASM_EXTABLE로 예외 처리를 등록합니다.

/* arch/x86/lib/copy_user_64.S — 유저 메모리 복사 (REP MOVSB) */
SYM_FUNC_START(copy_user_generic_unrolled)
    ASM_STAC                              # SMAP 해제 (유저 메모리 접근 허용)
    movq    %rdx, %rcx                   # count → RCX
1:  rep movsb                            # RSI(src)→RDI(dst), RCX 바이트
    ASM_CLAC                              # SMAP 복원
    xorl    %eax, %eax                   # 성공: 잔여 바이트 0 반환
    RET

/* 페이지 폴트 발생 시 복구 핸들러 */
.Lcopy_user_fault:
    movq    %rcx, %rax                   # 복사하지 못한 잔여 바이트 반환
    ASM_CLAC
    RET

    /* 예외 테이블: 1:에서 폴트 → .Lcopy_user_fault로 점프 */
    _ASM_EXTABLE_UA(1b, .Lcopy_user_fault)
SYM_FUNC_END(copy_user_generic_unrolled)

Per-CPU 변수 접근

x86_64에서 per-CPU 변수는 GS 세그먼트를 통해 접근합니다. 커널 모드에서 GS 베이스는 MSR_GS_BASE에 per-CPU 영역 시작 주소를 저장합니다.

/* arch/x86/include/asm/percpu.h — Per-CPU 접근 */
/* GS 세그먼트 베이스 = per-CPU 영역 시작 주소
 * __per_cpu_offset[cpu]에 해당하는 값이 GS 베이스로 설정됨
 * 변수 접근 시 %gs:offset 으로 직접 메모리 참조 */

#define this_cpu_read_8(pcp) ({              \
    u64 val;                                  \
    asm volatile("movq %%gs:%1, %0"           \
                 : "=r"(val)                   \
                 : "m"(pcp));                   \
    val; })

#define this_cpu_inc_8(pcp)                   \
    asm volatile("incq %%gs:%0"                \
                 : "+m"(pcp))

/* 사용 예: current 매크로 (현재 태스크 포인터) */
#define current this_cpu_read_stable(pcpu_hot.current_task)

ALTERNATIVE 매크로 (조건부 패칭)

CPU 기능에 따라 부팅 시 코드를 동적으로 패칭합니다. 기본 코드와 대체 코드를 함께 배치하고, 런타임에 CPU 기능을 확인하여 패칭합니다.

/* arch/x86/include/asm/alternative.h — ALTERNATIVE 매크로 */
/*
 * 기본 코드(oldinstr)를 배치하고, 대체 코드(newinstr)는
 * .altinstructions 섹션에 메타데이터와 함께 기록.
 * 부팅 시 apply_alternatives()가 CPU feature 확인 후
 * 기본 코드를 대체 코드로 덮어씀.
 */

/* 예: SWAPGS 대신 WRGSBASE 사용 (FSGSBASE 지원 시) */
ALTERNATIVE "swapgs",                       \
            "wrgsbase %rax",                 \
            X86_FEATURE_FSGSBASE

/* 예: REP MOVSB 대신 ERMS 버전 사용 */
ALTERNATIVE "rep movsb",                     \
            "call enhanced_rep_movsb",        \
            X86_FEATURE_ERMS

/* 이중 대체: feature1 없으면 기본, feature1이면 alt1, feature2면 alt2 */
ALTERNATIVE_2 "mfence; lfence",              \
              "lfence", X86_FEATURE_LFENCE_RDTSC, \
              "nop",    X86_FEATURE_SERIALIZE

세그멘테이션과 GDT/TSS

x86_64 Long Mode에서 세그멘테이션은 대부분 비활성화되지만, GDT(Global Descriptor Table)는 여전히 필수입니다. 커널/유저 코드 세그먼트의 특권 레벨, TSS(Task State Segment)의 스택 포인터, SYSCALL/SYSRET의 MSR 설정 등에서 세그먼트 디스크립터가 사용됩니다.

GDT 레이아웃 다이어그램

GDT는 per-CPU로 할당되며, 커널/유저 세그먼트와 TSS를 포함합니다. Long Mode에서 세그먼트의 base/limit은 무시되지만(FS/GS 제외), DPL과 타입 필드는 여전히 검증됩니다.

GDT 초기화

부팅 초기에 per-CPU GDT를 설정하고 LGDT로 프로세서에 로드합니다.

/* arch/x86/kernel/cpu/common.c — GDT 초기화 */
DEFINE_PER_CPU_PAGE_ALIGNED(struct gdt_page, gdt_page) = { .gdt = {
    [GDT_ENTRY_KERNEL_CS]       = GDT_ENTRY_INIT(0xa09b, 0, 0xfffff),
    /* flags: G=1, L=1, P=1, DPL=0, S=1, Type=Code R/A */
    [GDT_ENTRY_KERNEL_DS]       = GDT_ENTRY_INIT(0xc093, 0, 0xfffff),
    [GDT_ENTRY_DEFAULT_USER_CS] = GDT_ENTRY_INIT(0xa0fb, 0, 0xfffff),
    /* flags: G=1, L=1, P=1, DPL=3, S=1, Type=Code R/A */
    [GDT_ENTRY_DEFAULT_USER_DS] = GDT_ENTRY_INIT(0xc0f3, 0, 0xfffff),
}};

/* arch/x86/kernel/cpu/common.c — LGDT 로드 */
static inline void load_gdt(const struct desc_ptr *dtr)
{
    asm volatile("lgdt %0" :: "m"(*dtr));
}

TSS 설정

TSS는 Long Mode에서 IST(Interrupt Stack Table)와 IO 비트맵(Bitmap)을 제공합니다. 특권 레벨 전환 시 사용할 커널 스택을 지정합니다.

/* arch/x86/include/asm/processor.h — TSS 구조체 */
struct tss_struct {
    struct x86_hw_tss      x86_tss;       /* 하드웨어 TSS */
    struct x86_io_bitmap   io_bitmap;     /* IO 포트 비트맵 */
} __aligned(PAGE_SIZE);

struct x86_hw_tss {
    u32     reserved1;
    u64     sp0;           /* Ring 3→0 전환 시 커널 스택 */
    u64     sp1;           /* Ring 1 스택 (미사용) */
    u64     sp2;           /* Ring 2 스택 (SYSCALL 임시 저장용) */
    u64     reserved2;
    u64     ist[7];       /* IST 1~7: 전용 인터럽트 스택 */
    /* IST1: #DF (Double Fault)
     * IST2: #NMI
     * IST3: #DB (Debug)
     * IST4: #MC (Machine Check) */
    u32     reserved3;
    u16     reserved4;
    u16     io_bitmap_base;  /* IO 비트맵 오프셋 */
} __packed;

SYSCALL/SYSRET MSR 설정

SYSCALL/SYSRET 명령어의 동작을 제어하는 MSR을 부팅 시 초기화합니다.

/* arch/x86/kernel/cpu/common.c — SYSCALL MSR 초기화 */
void syscall_init(void)
{
    /* STAR: SYSCALL/SYSRET CS/SS 베이스 */
    wrmsrl(MSR_STAR,
           ((u64)__USER32_CS << 48) |    /* SYSRET CS base (유저 복귀) */
           ((u64)__KERNEL_CS << 32));    /* SYSCALL CS base (커널 진입) */

    /* LSTAR: SYSCALL 진입점 */
    wrmsrl(MSR_LSTAR, (unsigned long)entry_SYSCALL_64);

    /* SFMASK: SYSCALL 시 클리어할 RFLAGS 비트
     * IF=0 (인터럽트 비활성), TF=0 (트레이스 비활성),
     * DF=0 (방향 플래그 클리어), AC=0 (SMAP 활성 유지) */
    wrmsrl(MSR_SYSCALL_MASK,
           X86_EFLAGS_TF | X86_EFLAGS_DF | X86_EFLAGS_IF |
           X86_EFLAGS_IOPL | X86_EFLAGS_AC | X86_EFLAGS_NT);
}

인터럽트/예외 처리 흐름

x86_64에서 인터럽트와 예외는 IDT(Interrupt Descriptor Table)를 통해 처리됩니다. 프로세서는 인터럽트 벡터 번호로 IDT를 색인하여 게이트 디스크립터에서 핸들러 주소를 가져옵니다. 예외(0~31번)는 동기적이고, 외부 인터럽트(32~255번)는 APIC을 통해 비동기적으로 전달됩니다.

인터럽트 처리 흐름 다이어그램

하드웨어 인터럽트가 도착하면 Local APIC → IDT → 핸들러 체인 → EOI 순서로 처리됩니다.

IDT 게이트 디스크립터

64-bit IDT 게이트는 16바이트 크기로, 핸들러 주소 64-bit 전체와 IST 인덱스, DPL을 포함합니다.

/* arch/x86/include/asm/desc_defs.h — IDT 게이트 디스크립터 */
struct gate_struct {
    u16     offset_low;     /* 핸들러 주소 [15:0] */
    u16     segment;        /* 코드 세그먼트 셀렉터 (__KERNEL_CS) */
    struct idt_bits bits;
    u16     offset_middle;  /* 핸들러 주소 [31:16] */
    u32     offset_high;    /* 핸들러 주소 [63:32] */
    u32     reserved;
};

struct idt_bits {
    u16     ist  : 3;       /* IST 인덱스 (0=미사용, 1~7=전용 스택) */
    u16     zero : 5;
    u16     type : 4;       /* 0xE=Interrupt Gate, 0xF=Trap Gate */
    u16     dpl  : 2;       /* DPL (0=커널만, 3=유저 INT3 허용) */
    u16     p    : 1;       /* Present */
};
/* Interrupt Gate: IF 자동 클리어 (인터럽트 비활성)
 * Trap Gate: IF 유지 (예외 처리 중 인터럽트 가능) */

인터럽트 진입 어셈블리

모든 인터럽트 벡터는 매크로로 생성된 스텁에서 공통 핸들러로 점프합니다.

/* arch/x86/entry/entry_64.S — 인터럽트 진입 */
SYM_CODE_START(asm_common_interrupt)
    UNWIND_HINT_ENTRY
    ASM_CLAC                              # SMAP: 유저 접근 불가로 설정
    pushq   $-1                           # pt_regs→orig_ax = -1 (인터럽트 표시)
    PUSH_AND_CLEAR_REGS                   # 범용 레지스터 전체 저장
    testb   $3, CS(%rsp)                  # CS의 RPL 확인
    jz      1f                             # 커널 → SWAPGS 불필요
    swapgs                                # 유저에서 왔으면 GS 전환
    SWITCH_TO_KERNEL_CR3 scratch_reg=%rdi # KPTI 커널 CR3
1:  movq    %rsp, %rdi                    # pt_regs → 1번째 인자
    movq    %rsp, %rsi
    callq   common_interrupt              # C 핸들러 호출
    jmp     ret_from_intr                # 복귀 경로
SYM_CODE_END(asm_common_interrupt)

APIC EOI 시퀀스

인터럽트 처리 완료 후 Local APIC에 EOI(End Of Interrupt)를 보내 다음 인터럽트를 수신 가능하게 합니다.

/* arch/x86/kernel/apic/apic.c — APIC EOI */
static inline void apic_eoi(void)
{
    /* EOI 레지스터에 0을 쓰면 가장 높은 우선순위의 ISR 비트 클리어 */
    apic_write(APIC_EOI, 0);
}

/* x2APIC 모드: MSR을 통한 EOI (더 빠름) */
static inline void x2apic_eoi(void)
{
    wrmsrl(APIC_BASE_MSR + (APIC_EOI >> 4), 0);
}

/* 인터럽트 처리 완료 흐름 */
void handle_edge_irq(struct irq_desc *desc)
{
    handle_irq_event(desc);     /* handler 체인 실행 */
    cond_unmask_eoi_irq(desc, chip); /* chip→irq_eoi() → apic_eoi() */
}

CET (IBT/Shadow Stack)

CET(Control-flow Enforcement Technology)는 Intel이 도입한 하드웨어 제어 흐름 무결성(CFI) 기술로, IBT(Indirect Branch Tracking)와 Shadow Stack 두 가지 메커니즘으로 구성됩니다. 리눅스 커널 6.2+에서 IBT, 6.6+에서 유저 공간 Shadow Stack을 지원합니다.

CET 동작 흐름 다이어그램

IBT는 간접 호출 대상이 ENDBR64로 시작하는지 검증하고, Shadow Stack은 CALL/RET 시 반환 주소를 이중 검증합니다.

ENDBR64 어노테이션

IBT가 활성화되면 모든 간접 분기 대상은 ENDBR64로 시작해야 합니다. 커널은 objtool로 검증합니다.

/* arch/x86/include/asm/ibt.h — IBT 어노테이션 */
#ifdef CONFIG_X86_KERNEL_IBT
/* ENDBR64 = F3 0F 1E FA (4바이트 NOP on non-CET CPUs) */
#define __noendbr  __attribute__((nocf_check))

/* 어셈블리에서의 ENDBR */
SYM_FUNC_START(my_function)
    endbr64                  # IBT landing pad — 간접 호출 허용 지점
    pushq   %rbp
    ...

/* C 함수: 컴파일러가 자동으로 ENDBR64 삽입 (-fcf-protection=branch)
 * 함수 포인터로 호출될 수 있는 모든 함수에 필수
 * objtool이 누락된 ENDBR을 감지하여 빌드 경고 */

/* FineIBT (v6.2+): kCFI + IBT 결합
 * 간접 호출 전에 타입 해시 검증 → ENDBR에서 해시 비교
 * JOP 공격에 대한 더 강력한 보호 */
#else
#define __noendbr
#endif

Shadow Stack 설정

Shadow Stack은 CR4.CET와 MSR로 활성화하며, 유저 공간에서 map_shadow_stack 시스템 콜로 Shadow Stack 메모리를 할당합니다.

/* arch/x86/kernel/shstk.c — Shadow Stack 설정 */
int shstk_setup(void)
{
    struct thread_shstk *shstk = &current->thread.shstk;
    unsigned long addr, size;

    /* Shadow Stack 페이지 할당 (VM_SHADOW_STACK 플래그)
     * PTE: Dirty=0, Write=1 조합은 Shadow Stack 전용
     * 일반 소프트웨어가 이 페이지에 쓰기 불가 */
    size = PAGE_ALIGN(min_t(unsigned long, rlimit(RLIMIT_STACK), SZ_4G));
    addr = do_mmap(NULL, 0, size,
                   PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, 0,
                   &unused, NULL);

    set_clr_bits_msrl(MSR_IA32_U_CET, CET_SHSTK_EN, 0);
    wrmsrl(MSR_IA32_PL3_SSP, addr + size);   # 유저 SSP 설정 */
    shstk->base = addr;
    shstk->size = size;
    return 0;
}

/* CR4.CET 활성화 */
cr4_set_bits(X86_CR4_CET);

alternatives 패칭

리눅스 커널의 alternatives 시스템은 부팅 시 CPU 기능에 따라 명령어를 동적으로 교체합니다. 기본 코드(모든 CPU에서 동작)와 대체 코드(특정 기능 지원 시 사용)를 함께 빌드하고, apply_alternatives()가 런타임에 패칭합니다.

ALTERNATIVE 매크로 구조

.altinstructions 섹션에 메타데이터를 기록하고, .altinstr_replacement에 대체 코드를 배치합니다.

/* arch/x86/include/asm/alternative.h — ALTERNATIVE 내부 구조 */
struct alt_instr {
    s32 instr_offset;      /* 원본 명령어 위치 (.text 내) */
    s32 repl_offset;       /* 대체 명령어 위치 (.altinstr_replacement) */
    u16 cpuid;             /* X86_FEATURE_* (CPU 기능 비트) */
    u8  instrlen;          /* 원본 명령어 길이 */
    u8  replacementlen;    /* 대체 명령어 길이 */
};

/* ALTERNATIVE 매크로 확장 예:
 * .section .text
 * 770:  oldinstr            ← 기본 코드 (모든 CPU)
 * 771:  .skip (pad)         ← NOP 패딩 (대체 코드가 더 길 경우)
 *
 * .section .altinstr_replacement
 * 772:  newinstr            ← 대체 코드
 *
 * .section .altinstructions
 *   .long 770b - .          ← instr_offset (상대)
 *   .long 772b - .          ← repl_offset (상대)
 *   .word X86_FEATURE_XXX   ← 필요한 CPU 기능
 *   .byte 771b - 770b       ← instrlen
 *   .byte 773f - 772b       ← replacementlen
 */

apply_alternatives 패칭 과정

부팅 초기에 apply_alternatives()가 .altinstructions 섹션을 순회하며 CPU 기능을 확인하고, 지원되는 기능의 대체 코드로 원본을 덮어씁니다.

/* arch/x86/kernel/alternative.c — 패칭 엔진 */
void __init_or_module apply_alternatives(struct alt_instr *start,
                                         struct alt_instr *end)
{
    struct alt_instr *a;
    u8 *instr, *replacement;

    for (a = start; a < end; a++) {
        instr = (u8 *)&a->instr_offset + a->instr_offset;
        replacement = (u8 *)&a->repl_offset + a->repl_offset;

        if (!boot_cpu_has(a->cpuid))
            continue;                   /* CPU가 해당 기능 미지원 → 스킵 */

        /* text_poke_early(): .text 영역에 직접 쓰기
         * 대체 코드를 원본 위치에 복사
         * 잔여 공간은 NOP으로 채움 */
        text_poke_early(instr, replacement, a->replacementlen);
        add_nops(instr + a->replacementlen,
                 a->instrlen - a->replacementlen);
    }
}

static_cpu_has와 NOP 패딩

C 코드에서 static_cpu_has()는 조건 분기를 NOP으로 패칭하여 분기 예측 오버헤드를 제거합니다.

/* arch/x86/include/asm/cpufeature.h — static_cpu_has */
/* 부팅 시: 해당 기능이 있으면 JMP를 2-byte NOP으로 교체
 *          없으면 JMP를 유지하여 대체 경로로 분기 */

static __always_inline bool _static_cpu_has(u16 bit)
{
    asm goto(
        ALTERNATIVE_TERNARY(
            "jmp %l[t_no]",               /* 기본: no로 점프 */
            %P[cap],                          /* X86_FEATURE_* */
            "",                               /* 기능 있음: NOP (fall-through → true) */
            "jmp %l[t_no]")                  /* 기능 없음: 점프 유지 */
        : : [cap] "i"(bit) : : t_no);
    return true;
t_no:
    return false;
}

/* 사용 예: FSGSBASE 지원 시 RDGSBASE 사용 */
if (static_cpu_has(X86_FEATURE_FSGSBASE))
    gs_base = rdgsbase();           /* 패칭 후: NOP → fall-through */
else
    gs_base = rdmsrl(MSR_GS_BASE);  /* 패칭 전/미지원: MSR 읽기 */

마이크로아키텍처 최적화

최신 x86_64 프로세서는 CISC 명령어를 내부적으로 µop(마이크로 연산)으로 분해하여 처리합니다. 프론트엔드(명령어 페치/디코드)와 백엔드(실행/은퇴) 파이프라인의 특성을 이해하면 커널 핫패스의 성능을 최적화할 수 있습니다.

파이프라인 단계 다이어그램

x86_64 프로세서의 파이프라인은 프론트엔드, 스케줄러, 백엔드로 구분되며, 각 단계에서 최적화 기회가 있습니다.

분기 예측 힌트

커널은 likely()/unlikely() 매크로로 GCC에 분기 방향 힌트를 제공합니다.

/* include/linux/compiler.h — 분기 예측 힌트 */
#define likely(x)    __builtin_expect(!!(x), 1)
#define unlikely(x)  __builtin_expect(!!(x), 0)

/* GCC는 likely 경로를 fall-through(JCC not-taken)로 배치
 * → 분기 예측기의 정적 예측(forward not-taken)과 일치
 * → 파이프라인 플러시 최소화 */

/* 사용 예: 페이지 폴트 핸들러 */
if (likely(!(fault & VM_FAULT_ERROR))) {
    /* 정상 경로: 대부분의 페이지 폴트는 성공 */
    return;
}
if (unlikely(fault & VM_FAULT_OOM)) {
    /* OOM: 매우 드문 경로 → .text.unlikely 섹션으로 분리 */
    pagefault_out_of_memory();
}

루프 정렬과 NOP

핫 루프를 캐시라인/µop 캐시 경계에 정렬하면 프론트엔드 대역폭을 극대화할 수 있습니다.

/* 커널 루프 정렬 예시 */

/* .balign 지시자: 다음 명령어를 지정 바이트 경계에 정렬
 * 최적 NOP 패딩 삽입 (ideal_nops 테이블에서 선택) */
    .balign 32                  # 32바이트 경계 정렬 (µop 캐시 라인)
.Lloop:
    movq    (%rsi), %rax
    movq    %rax, (%rdi)
    addq    $8, %rsi
    addq    $8, %rdi
    decq    %rcx
    jnz     .Lloop              # 루프 상단이 정렬되어 fetch 효율 최적

/* arch/x86/kernel/alternative.c — 최적 NOP 선택 */
/* ideal_nops[N]: N바이트 NOP 패딩
 * 1: 0x90 (NOP)
 * 2: 66 90 (66 NOP)
 * 3: 0F 1F 00 (NOP DWORD ptr [RAX])
 * ...
 * 8+: 0F 1F 84 00 00 00 00 00 (long NOP) */

µop 캐시 고려사항

µop 캐시(DSB)에 핫 코드가 완전히 적재되면 디코더를 우회하여 처리량(Throughput)이 향상됩니다.

/* µop 캐시 효율성 체크 (perf 이벤트) */
# DSB(µop 캐시) vs MITE(레거시 디코더) 비율 확인
$ perf stat -e idq.dsb_uops,idq.mite_uops ./workload

/* 커널 핫패스 최적화 원칙:
 * 1. 함수 크기를 µop 캐시 way(~32B 윈도우)에 맞춤
 * 2. 드문 에러 경로를 __cold로 분리 (out-of-line)
 * 3. 복잡한 명령어(예: DIV)는 다수 µop → 대안 사용
 *    (곱셈+시프트로 나눗셈 대체: reciprocal_divide)
 * 4. LOCK 접두사: 캐시라인 정렬 데이터에서만 사용
 *    (split lock은 ~100x 느림 → 커널 split_lock_detect) */

/* 예: reciprocal division (나눗셈을 곱셈으로 대체) */
static inline u32 reciprocal_divide(u32 a, struct reciprocal_value R)
{
    /* DIV(~30 µop) 대신 MUL+SHR(2 µop)로 대체 */
    return (u32)(((u64)a * R.m) >> R.sh);
}

VMX/SVM 명령어

x86_64 가상화는 Intel VT-x(VMX)와 AMD-V(SVM) 두 가지 하드웨어 확장으로 지원됩니다. 하이퍼바이저(KVM)는 VMX/SVM 명령어로 가상 머신을 생성하고 VM Entry/Exit 전환을 수행합니다.

VMCS/VMCB 구조와 VM Entry/Exit 흐름

VMCS(Intel)와 VMCB(AMD)는 게스트 상태, 호스트 상태, 제어 필드를 포함하는 4KB 구조체입니다.

VMXON/VMLAUNCH 시퀀스

KVM이 VMX를 초기화하고 게스트를 실행하는 과정입니다.

/* arch/x86/kvm/vmx/vmx.c — VMX 초기화 및 게스트 실행 */

/* 1. VMXON: VMX root 모드 진입 */
static int vmx_hardware_enable(void)
{
    /* CR4.VMXE = 1 (VMX 활성화) */
    cr4_set_bits(X86_CR4_VMXE);

    /* VMXON: 4KB VMXON 영역 물리 주소 전달 */
    asm volatile("vmxon %0" : : "m"(phys_addr) : "memory", "cc");
    return 0;
}

/* 2. VMLAUNCH/VMRESUME: 게스트 실행 */
static noinstr void vmx_vcpu_enter_exit(struct kvm_vcpu *vcpu)
{
    /* 호스트 레지스터 저장 */
    asm volatile(
        "pushq %%rbp\n\t"
        "pushq %%rcx\n\t"
        /* ... 호스트 callee-saved 저장 ... */

        /* 게스트 레지스터 로드 */
        "movq %c[rax](%[regs]), %%rax\n\t"
        "movq %c[rbx](%[regs]), %%rbx\n\t"
        /* ... 나머지 레지스터 ... */

        /* VM Entry! */
        "cmpb $0, %[launched]\n\t"
        "jne .Lvmresume\n\t"
        "vmlaunch\n\t"             # 첫 실행
        "jmp .Lvmfail\n\t"
    ".Lvmresume:\n\t"
        "vmresume\n\t"             # 재실행
        /* VM-Exit 시 여기로 복귀 → 게스트 레지스터 저장 */
    );
}

VMCS 필드 읽기/쓰기

VMCS는 VMREAD/VMWRITE 명령어로만 접근 가능한 구조화된 데이터입니다.

/* arch/x86/kvm/vmx/vmcs.h — VMCS 필드 접근 */
static __always_inline unsigned long vmcs_readl(unsigned long field)
{
    unsigned long value;
    asm volatile("vmread %1, %0"
                 : "=r"(value) : "r"(field) : "cc");
    return value;
}

static __always_inline void vmcs_writel(unsigned long field, unsigned long value)
{
    asm volatile("vmwrite %1, %0"
                 :: "r"(field), "rm"(value) : "cc");
}

/* 주요 VMCS 필드 */
#define GUEST_RIP          0x681E   /* 게스트 명령어 포인터 */
#define GUEST_RSP          0x681C   /* 게스트 스택 포인터 */
#define GUEST_CR3          0x6802   /* 게스트 CR3 (EPT 사용 시 GPA) */
#define VM_EXIT_REASON     0x4402   /* Exit 사유 (16-bit) */
#define EXIT_QUALIFICATION 0x6400   /* Exit 상세 정보 */
#define EPT_POINTER        0x201A   /* EPT PML4 물리 주소 */

/* VM-Exit 후 사유 확인 */
u32 reason = vmcs_read32(VM_EXIT_REASON);
kvm_vmx_exit_handlers[reason](vcpu);  /* 핸들러 디스패치 */

디버그 레지스터/하드웨어 브레이크포인트

x86_64는 4개의 디버그 주소 레지스터(DR0-DR3)와 상태/제어 레지스터(DR6/DR7)를 통해 하드웨어 브레이크포인트를 지원합니다. 소프트웨어 브레이크포인트(INT3)와 달리 코드 수정 없이 메모리 접근/실행을 모니터링할 수 있어 watchpoint와 커널 디버깅에 필수적입니다.

DR7 제어 레지스터 비트 레이아웃

DR0-DR3 주소 설정

디버그 주소 레지스터에 감시할 선형 주소를 설정합니다. 커널은 set_debugreg() 매크로로 접근합니다.

/* arch/x86/include/asm/debugreg.h — 디버그 레지스터 접근 */
#define set_debugreg(value, reg)                       \
    asm volatile("movq %0, %%db" #reg                  \
                 :: "r"((unsigned long)(value)))

#define get_debugreg(var, reg)                         \
    asm volatile("movq %%db" #reg ", %0"                \
                 : "=r"(var))

/* 하드웨어 브레이크포인트 설정 예 */
void hw_breakpoint_set(int bp_num, unsigned long addr)
{
    switch (bp_num) {
    case 0: set_debugreg(addr, 0); break;  /* DR0 */
    case 1: set_debugreg(addr, 1); break;  /* DR1 */
    case 2: set_debugreg(addr, 2); break;  /* DR2 */
    case 3: set_debugreg(addr, 3); break;  /* DR3 */
    }
}

DR7 구성 (타입, 크기, 활성화)

DR7은 각 브레이크포인트의 타입(실행/읽기/쓰기), 크기(1/2/4/8바이트), 로컬/글로벌 활성 비트를 제어합니다.

/* arch/x86/kernel/hw_breakpoint.c — DR7 설정 */
unsigned long encode_dr7(int drnum, unsigned len, unsigned type)
{
    unsigned long dr7 = 0;

    /* Local enable 비트 (DR7[2*drnum]) */
    dr7 |= (1UL << (drnum * 2));

    /* R/W 필드: 비트 [16+4*drnum : 17+4*drnum]
     * 00 = 실행 (X)
     * 01 = 데이터 쓰기만 (W)
     * 10 = I/O 읽기/쓰기 (CR4.DE=1 필요)
     * 11 = 데이터 읽기+쓰기 (RW) */
    dr7 |= ((unsigned long)type << (16 + drnum * 4));

    /* LEN 필드: 비트 [18+4*drnum : 19+4*drnum]
     * 00 = 1바이트
     * 01 = 2바이트
     * 10 = 8바이트 (x86_64에서만)
     * 11 = 4바이트 */
    dr7 |= ((unsigned long)len << (18 + drnum * 4));

    return dr7;
}

/* DR7 적용 */
unsigned long dr7;
get_debugreg(dr7, 7);
dr7 |= encode_dr7(0, DR7_LEN_4, DR7_BREAK_ON_WRITE);  /* BP0: 4B 쓰기 감시 */
set_debugreg(dr7, 7);

perf_event 하드웨어 브레이크포인트 API

유저 공간에서는 perf_event_open()을 통해 하드웨어 브레이크포인트를 설정할 수 있으며, 커널 내부에서는 register_wide_hw_breakpoint()를 사용합니다.

/* kernel/events/hw_breakpoint.c — 커널 hw_breakpoint API */
struct perf_event * register_wide_hw_breakpoint(
    struct perf_event_attr *attr,
    perf_overflow_handler_t triggered,
    void *context)
{
    /* 모든 CPU에서 하드웨어 브레이크포인트 등록
     * attr→bp_type: HW_BREAKPOINT_W, HW_BREAKPOINT_RW, HW_BREAKPOINT_X
     * attr→bp_len: HW_BREAKPOINT_LEN_1/2/4/8
     * attr→bp_addr: 감시할 가상 주소
     * triggered: #DB 발생 시 호출되는 콜백 */
}

/* 사용 예: 커널 변수 감시 (watchpoint) */
struct perf_event_attr attr = {
    .type           = PERF_TYPE_BREAKPOINT,
    .bp_type        = HW_BREAKPOINT_W,       /* 쓰기 감시 */
    .bp_addr        = (unsigned long)&watched_var,
    .bp_len         = HW_BREAKPOINT_LEN_8,   /* 8바이트 */
    .disabled       = 0,
};
struct perf_event *bp = register_wide_hw_breakpoint(
    &attr, my_bp_handler, NULL);

/* #DB 핸들러: DR6에서 트리거된 브레이크포인트 확인 */
void my_bp_handler(struct perf_event *bp,
                    struct perf_sample_data *data,
                    struct pt_regs *regs)
{
    pr_info("watchpoint hit at %pS\n", (void *)regs->ip);
    /* DR6 비트: B0-B3 → 어떤 DR0-DR3가 트리거
     * BD(13) → DR 접근 감지, BS(14) → 단일 스텝, BT(15) → 태스크 전환 */
}

참고 링크

• Intel 64 and IA-32 Architectures Software Developer Manuals (Intel SDM) — x86_64 전체 명령어 인코딩, 오퍼랜드, 동작을 정의하는 공식 레퍼런스입니다
• AMD64 Architecture Programmer's Manual — AMD64 명령어셋 확장 및 호환성 정보를 제공합니다
• 커널 소스: arch/x86/include/asm/asm.h — 커널 어셈블리 매크로 및 인라인 어셈블리 헬퍼 정의입니다
• 커널 소스: arch/x86/lib/atomic64_cx8_32.S — CMPXCHG8B 기반 원자적 연산 어셈블리 구현입니다
• 커널 소스: arch/x86/entry/entry_64.S — SYSCALL/SYSRET 진입점, 인터럽트 핸들러 어셈블리입니다
• 커널 소스: arch/x86/include/asm/special_insns.h — CR/DR 레지스터 접근, WBINVD 등 특권 명령어 래퍼입니다
• 커널 문서: x86_64 Memory Map (Documentation/arch/x86/x86_64/mm.rst) — x86_64 가상 메모리 레이아웃 문서입니다
• 커널 문서: Kernel entries on x86-64 (Documentation/arch/x86/entry_64.rst) — 시스템 콜, 인터럽트 진입 경로 설명입니다
• LWN.net: Software alternatives for x86 instructions — 커널 alternatives 메커니즘으로 런타임 명령어 패칭하는 방법입니다
• LWN.net: Linear Address Masking (LAM) — x86_64 주소 마스킹 확장 명령어 지원 논의입니다
• 커널 소스: arch/x86/include/asm/barrier.h — MFENCE/LFENCE/SFENCE 메모리 배리어 매크로 정의입니다
• 커널 소스: arch/x86/include/asm/percpu.h — GS 세그먼트 기반 per-CPU 변수 접근 명령어 구현입니다
• OSDev Wiki: X86-64 Instruction Encoding — REX/VEX/EVEX 접두사와 명령어 인코딩 형식 참고 자료입니다

관련 문서