어셈블리 종합 (Assembly)

커널 개발에서 필요한 어셈블리 지식을 ABI·성능·안전성 관점으로 심층 정리합니다. GCC 인라인 어셈블리 제약조건과 clobber 규칙, 오퍼랜드 형식(ModR/M·SIB·RIP-상대), asm goto와 Static Key 패칭, x86-64/ARM64/RISC-V 레지스터 심화, REX/VEX/EVEX 인코딩 상세, CFI/ORC 스택 해제, 문자열 연산(ERMS/FSRM)과 copy_user, 비트 조작(BSF/BMI), 특권 명령어(VMX/SGX/SMAP), Spectre/Meltdown/MDS 완화(IBRS/KPTI/VERW), 성능 카운터(PMU/RDTSC), 호출 규약 심화(Red Zone/Windows x64), AVX-512/AMX까지 다룹니다.

인라인 어셈블리 개요

Linux 커널은 성능 최적화, 하드웨어 직접 제어, 원자적 연산 등을 위해 인라인 어셈블리를 사용합니다. GCC의 asm (또는 __asm__) 키워드를 사용합니다.

GCC 인라인 어셈블리 문법

asm volatile (
    "assembly template"            /* 어셈블리 코드 */
    : output operands              /* 출력 (optional) */
    : input operands               /* 입력 (optional) */
    : clobbers                     /* 변경되는 레지스터/메모리 */
);

/* 예: x86 rdtsc (TSC 읽기) */
static inline u64 rdtsc(void)
{
    u32 lo, hi;
    asm volatile ("rdtsc" : "=a"(lo), "=d"(hi));
    return ((u64)hi << 32) | lo;
}

/* 예: CR3 레지스터 읽기 (현재 페이지 테이블) */
static inline unsigned long read_cr3(void)
{
    unsigned long val;
    asm volatile ("mov %%cr3, %0" : "=r"(val));
    return val;
}

오퍼랜드 제약조건

ARM64 제약조건

RISC-V 제약조건

오퍼랜드 형식 심화

CPU 명령어의 오퍼랜드 인코딩을 이해하면 objdump 출력을 해석하고, 바이너리 패칭(ALTERNATIVE, static key)의 동작을 정확히 파악할 수 있습니다. x86의 가변 길이 CISC 인코딩, ARM64의 고정 폭 32비트 인코딩, RISC-V의 6가지 명령어 형식을 비교합니다.

x86 주소 지정 모드

/* AT&T 주소 지정 모드 문법: displacement(base, index, scale)
 * 유효 주소 = base + index × scale + displacement
 * scale: 1, 2, 4, 8
 * displacement: 8비트 또는 32비트 부호 확장 */

/* objdump 출력 예시: */
/* ffffffff81001234:  48 8b 04 cd 00 00 00 00    mov 0x0(,%rcx,8),%rax */
/*   ↑ REX.W   ↑ MOV r,r/m   ↑ ModRM+SIB    ↑ disp32=0 */
/*   ModRM: 00 000 100 → mod=00, reg=rax, rm=100(SIB)  */
/*   SIB:   11 001 101 → scale=8, index=rcx, base=disp32(no base) */

ModR/M 바이트 상세

ModR/M 바이트는 x86 명령어의 오퍼랜드를 지정하는 핵심 바이트입니다. 3개 필드(mod, reg, r/m)로 256가지 조합을 제공합니다.

SIB 바이트 상세

SIB(Scale-Index-Base) 바이트는 ModR/M에서 r/m=100일 때 사용되며, 복잡한 주소 계산을 제공합니다.

변위와 즉시값 인코딩

/* 즉시값 크기 규칙 */
/* MOV r64, imm64:       10바이트 (REX.W + B8+rd + imm64) — movabs */
/* MOV r/m64, imm32:     7바이트 (REX.W + C7 /0 + imm32, 부호확장) */
/* ADD r/m64, imm32:     7바이트 (REX.W + 81 /0 + imm32, 부호확장) */
/* ADD r/m64, imm8:      4바이트 (REX.W + 83 /0 + imm8, 부호확장) */

/* 커널에서의 최적화: GCC는 가능한 짧은 인코딩을 선택 */
/* movq $0, %rax   → 48 c7 c0 00 00 00 00 (7B, imm32 부호확장) */
/* xorq %rax, %rax → 48 31 c0             (3B, 더 짧고 빠름) */
/* addq $1, %rax   → 48 83 c0 01          (4B, imm8 부호확장) */

RIP-상대 주소 지정

64비트 모드에서 mod=00, r/m=101은 RIP-상대 주소를 의미합니다. 위치 독립 코드(PIC)와 커널 전역변수 접근에 핵심적입니다.

/* RIP-상대 주소 지정 */
/* 커널 전역변수 접근 */
    movq jiffies(%rip), %rax    /* RIP-상대: 위치 독립적 */

/* objdump 출력 예시: */
/* ffffffff81001000:  48 8b 05 f9 0f 00 00  mov 0xfff9(%rip),%rax */
/*   유효 주소 = RIP(다음 명령어) + 0x0ff9 = ffffffff81002000 */
/*   → jiffies 변수 주소 */

/* 32비트 모드에서 mod=00, r/m=101은 절대 주소(disp32)
 * 64비트 모드에서 mod=00, r/m=101은 RIP+disp32
 * → 32비트 코드를 64비트로 포팅 시 주의 필요 */

/* 커널은 KASLR 활성화 시 모든 전역변수를 RIP-상대로 접근
 * → 코드와 데이터가 함께 재배치되어도 올바르게 동작 */

ARM64 오퍼랜드 형식

ARM64(AArch64)는 모든 명령어가 32비트 고정 폭입니다. 오퍼랜드 인코딩이 명령어 비트 내에 고정 위치로 배치됩니다.

RISC-V 오퍼랜드 형식

RISC-V는 6가지 기본 명령어 형식을 정의합니다. 모든 형식은 32비트이며, opcode가 하위 7비트에 고정됩니다.

오퍼랜드 형식 실전 함정

asm goto 패턴

GCC의 asm goto 확장은 인라인 어셈블리에서 C 레이블로의 분기를 가능하게 합니다. 커널의 Static Key(jump_label) 메커니즘의 핵심 기반입니다.

asm goto 문법

/* asm goto 기본 문법 */
asm goto (
    "assembly template"
    :                             /* 출력 오퍼랜드 없음 (GCC 제한) */
    : input operands              /* 입력 */
    : clobbers                    /* 클러버 */
    : label1, label2, ...         /* C 레이블 목록 */
);

/* 레이블 참조: %l0, %l1, ... (순서 기반) */
/* 또는 %l[labelname] (이름 기반) */

/* 예: 조건부 분기 */
asm goto (
    "cmpq %0, %1\n\t"
    "jg %l[greater]"
    : : "r"(a), "r"(b)
    : "cc"
    : greater
);
/* a <= b 경로 */
return 0;

greater:
/* a > b 경로 */
return 1;

Static Key와 asm goto

Static Key(jump label)는 asm goto와 코드 패칭을 결합해, 거의 변하지 않는 조건을 핫 패스 안에 넣으면서도 기본 경로의 부담을 극단적으로 줄이는 메커니즘입니다. 일반 if (flag)는 매 호출마다 메모리에서 flag를 읽고, 값을 검사하고, 조건 분기를 수행합니다. 반면 Static Key는 기본 상태에서 그 자리에 5바이트 NOP 또는 5바이트 JMP를 직접 놓아 둡니다.

핵심은 비용의 위치를 바꾸는 것입니다. 상태가 바뀌지 않는 대부분의 시간에는 분기 선택 비용을 거의 없애고, 상태를 켜거나 끌 때만 텍스트 패칭 비용을 한 번 지불합니다. 그래서 tracepoint, 스케줄러 통계, 디버그 훅처럼 "평소에는 꺼져 있고, 켜더라도 오래 유지되는" 기능에 특히 잘 맞습니다.

왜 일반 bool 분기보다 빠른가

일반 분기는 "값을 읽고 판단"합니다. Static Key는 "기계어를 바꿔서 아예 다른 길로 만든다"는 점이 다릅니다. 즉, 조건 값이 메모리에 존재하는 것이 아니라, 분기 명령 자체가 텍스트 섹션에 박혀 있습니다. 이 차이 때문에 disabled fast path에서 데이터 캐시 접근과 조건 분기 일부를 통째로 없앨 수 있습니다.

컴파일부터 런타임 패칭까지의 파이프라인

Static Key는 C 매크로 하나로 끝나는 마법이 아닙니다. 컴파일러는 asm goto 기반 분기 슬롯을 만들고, 어셈블러/링커는 각 분기 사이트에 대한 메타데이터를 __jump_table에 모읍니다. 그리고 런타임에 static_branch_enable() 또는 static_branch_disable()가 호출되면, 해당 key를 참조하는 모든 사이트가 한 번에 패칭됩니다.

/* 권장 Static Key 사용 패턴 */
static DEFINE_STATIC_KEY_FALSE(net_trace_key);

void fast_rx(struct sk_buff *skb)
{
    /* 기본 false 상태에서는 이 자리의 branch slot이 NOP이다 */
    if (static_branch_unlikely(&net_trace_key))
        trace_rx_packet(skb);

    consume_skb(skb);
}

void trace_rx_enable(void)
{
    /* 동일 key를 참조하는 모든 site를 true 방향으로 패칭 */
    static_branch_enable(&net_trace_key);
}

void trace_rx_disable(void)
{
    static_branch_disable(&net_trace_key);
}

/* 개념 설명용 x86 출력 예시: 기본 false + static_branch_unlikely */
.Lsite:
    nopl 0x0(%rax,%rax,1)          /* 5바이트 NOP, fast path는 그냥 통과 */
    /* __jump_table에는 { .Lsite, .Lslow_path, &net_trace_key }가 기록됨 */
    ...
.Lafter_fast:
    ret

.Lslow_path:
    call trace_rx_packet
    jmp .Lafter_fast

/* enable 후 같은 슬롯 */
.Lsite:
    jmp .Lslow_path                /* 같은 5바이트 자리가 JMP rel32로 교체 */

권장 API와 상태 전이

DEFINE_STATIC_KEY_TRUE/FALSE는 "초기 상태"를 정하고, static_branch_likely/unlikely()는 "어느 경로를 기본 코드 배치로 둘지"를 표현합니다. 이름만 보면 분기 예측 힌트처럼 보이지만, 여기서는 런타임에 패칭될 branch slot의 기본 모양을 고르는 의미가 더 큽니다.

실전 판단 기준은 단순합니다. 상태가 자주 바뀌면 일반 분기, 상태가 거의 안 바뀌고 읽기만 매우 많으면 Static Key입니다. 바꿔 말하면 Static Key는 "읽기 최적화용"이지 "자주 토글하는 스위치"가 아닙니다.

x86에서 안전하게 패칭되는 이유

x86에서는 보통 NOP와 JMP를 같은 길이(대표적으로 5바이트)로 맞춰 둡니다. 이렇게 해야 실행 중인 코드를 다른 명령 길이로 뒤틀지 않고 같은 슬롯 안에서 교체할 수 있습니다. 실제 구현 세부는 아키텍처 코드가 담당하지만, x86의 대표 경로는 arch_jump_label_transform*()와 text_poke_bp() 계열 텍스트 패칭 루틴으로 이해하면 됩니다.

따라서 Static Key의 본질은 "분기 예측을 더 잘하자"가 아니라 분기 자체를 다른 기계어로 교체하자에 가깝습니다. enabled 상태에서도 JMP 자체의 비용과 slow path의 I-cache 부담은 남아 있으므로, 완전한 공짜는 아니지만 disabled hot path를 매우 싸게 만들 수 있다는 점이 중요합니다.

실전에서 자주 틀리는 부분

일반 인라인 어셈블리와 비교

레지스터 심화

x86-64, ARM64, RISC-V의 레지스터 구조를 시스템 레지스터까지 포함하여 심층 정리합니다.

x86-64 GPR 완전 맵

시스템 레지스터 CR/DR/MSR

/* 주요 MSR (Model Specific Register) */
/* IA32_EFER (0xC0000080): 확장 기능 활성 레지스터 */
/*   SCE(bit 0): SYSCALL 활성, LME(bit 8): Long Mode 활성 */
/*   NXE(bit 11): NX 비트 활성 */

/* IA32_LSTAR (0xC0000082): SYSCALL 진입점 */
/*   → entry_SYSCALL_64 주소 */

/* IA32_STAR (0xC0000081): SYSCALL/SYSRET 세그먼트 */
/*   [47:32]=커널 CS/SS, [63:48]=유저 CS/SS */

/* IA32_KERNEL_GS_BASE (0xC0000102): SWAPGS용 */
/*   커널 GS base ↔ 유저 GS base 교환 */

/* IA32_TSC_AUX (0xC0000103): RDTSCP 보조 */
/*   보통 CPU 번호 저장 */

SIMD 레지스터 맵

ARM64 시스템 레지스터

RISC-V CSR 완전 맵

/* RISC-V CSR 접근 */
static inline unsigned long csr_read(unsigned long csr)
{
    unsigned long val;
    asm volatile ("csrr %0, %1" : "=r"(val) : "i"(csr));
    return val;
}

/* 주요 S-mode CSR */
/* satp: 페이지 테이블 모드(Sv39/Sv48) + ASID + PPN */
/* sstatus: SIE(인터럽트활성), SPP(이전권한), SUM(유저접근) */
/* scause: 예외 원인 코드 (MSB: 인터럽트/예외 구분) */

시스템 콜 ABI

x86_64 시스템 콜 규약

/* x86_64 System V ABI - 시스템 콜 */
/*   syscall number: rax               */
/*   arguments:      rdi, rsi, rdx, r10, r8, r9 */
/*   return value:   rax                */
/*   clobbered:      rcx, r11           */

/* 시스템 콜 진입점 (entry_SYSCALL_64) */
SYM_CODE_START(entry_SYSCALL_64)
    swapgs                          /* GS base를 커널용으로 교체 */
    movq    %rsp, PER_CPU_VAR(cpu_tss_rw + TSS_sp2)
    movq    PER_CPU_VAR(cpu_current_top_of_stack), %rsp
    pushq   $__USER_DS              /* user SS */
    pushq   PER_CPU_VAR(cpu_tss_rw + TSS_sp2) /* user RSP */
    pushq   %r11                    /* user RFLAGS */
    pushq   $__USER_CS              /* user CS */
    pushq   %rcx                    /* user RIP */
    /* ... */
SYM_CODE_END(entry_SYSCALL_64)

커널에서 자주 사용하는 어셈블리 패턴

/* cmpxchg: Compare and exchange (atomic) */
static inline unsigned long cmpxchg_local(
    volatile void *ptr, unsigned long old, unsigned long new)
{
    unsigned long prev;
    asm volatile ("cmpxchgq %2, %1"
        : "=a"(prev), "+m"(*(unsigned long *)ptr)
        : "r"(new), "0"(old)
        : "memory");
    return prev;
}

/* CLI/STI: 인터럽트 비활성화/활성화 */
static inline void native_irq_disable(void)
{
    asm volatile ("cli" ::: "memory");
}

static inline void native_irq_enable(void)
{
    asm volatile ("sti" ::: "memory");
}

Atomic 연산 어셈블리 심화

커널의 모든 동기화 기본 요소(spinlock, atomic_t, refcount_t, bit 연산)는 궁극적으로 어셈블리 원자 명령어에 의존합니다. LOCK 접두사, CMPXCHG 루프, XADD, 128비트 CMPXCHG16B 등의 동작을 정확히 이해해야 합니다.

atomic_t 연산 구현

/* arch/x86/include/asm/atomic.h — atomic_t 핵심 연산 */

/* atomic_read: 단순 volatile 읽기 (자연 정렬 = 원자적) */
static inline int arch_atomic_read(const atomic_t *v)
{
    return __READ_ONCE(v->counter);  /* volatile 접근 */
}

/* atomic_add: LOCK ADD */
static inline void arch_atomic_add(int i, atomic_t *v)
{
    asm volatile (LOCK_PREFIX "addl %1,%0"
                 : "+m" (v->counter)
                 : "ir" (i)
                 : "memory");
}

/* atomic_fetch_add: LOCK XADD — 이전값 반환 */
static inline int arch_atomic_fetch_add(int i, atomic_t *v)
{
    return xadd(&v->counter, i);  /* lock xadd */
}

/* atomic_cmpxchg: LOCK CMPXCHG */
static inline int arch_atomic_cmpxchg(atomic_t *v, int old, int new)
{
    return cmpxchg(&v->counter, old, new);
}

/* try_cmpxchg: ZF 기반 (커널 6.1+ 선호 패턴) */
static inline bool arch_atomic_try_cmpxchg(atomic_t *v, int *old, int new)
{
    return try_cmpxchg(&v->counter, old, new);
    /* 성공: true, *old 불변 */
    /* 실패: false, *old = 현재값 (eax에서 자동 갱신) */
}

/* cmpxchg 매크로의 인라인 어셈블리 */
#define __raw_cmpxchg(ptr, old, new, size, lock) ({     \
    __typeof__(*(ptr)) __ret;                               \
    __typeof__(*(ptr)) __old = (old);                       \
    __typeof__(*(ptr)) __new = (new);                       \
    asm volatile (lock "cmpxchg" #size " %[new], %[ptr]" \
                 : "=a" (__ret), [ptr] "+m" (*(ptr))     \
                 : [new] "r" (__new), "0" (__old)          \
                 : "memory");                               \
    __ret;                                                   \
})

Ticket Spinlock / Queued Spinlock 어셈블리

/* 고전적 Ticket Spinlock (개념적 구현) */
/* owner|next가 16비트씩 합쳐진 32비트 값 */
arch_spin_lock:
    movl    $0x00010000, %eax     /* next 필드에 1 추가 */
    lock xadd %eax, (%rdi)        /* fetch_add: eax = 이전값 */
    movzwl  %ax, %ecx             /* owner = 하위 16비트 */
    shrl    $16, %eax             /* ticket = 상위 16비트 */
    cmpl    %eax, %ecx
    je      .Lgot_lock            /* 내 ticket == owner → 획득 */
.Lspin:
    pause                          /* CPU 힌트: 스핀 대기 */
    movzwl  (%rdi), %ecx          /* owner 폴링 */
    cmpl    %eax, %ecx
    jne     .Lspin
.Lgot_lock:
    RET

/* Queued Spinlock (MCS 기반, 현재 커널 기본) */
/* arch/x86/include/asm/qspinlock.h */
/* 4바이트: locked:pending:tail (8:8:16 비트) */
/* Fast path: LOCK CMPXCHG로 locked=0 → locked=1 */
/* Slow path: MCS 큐에 노드 추가 → queued_spin_lock_slowpath() */

LOCK 접두사 인코딩과 메모리 순서

LOCK 접두사(0xF0)는 특정 명령어에만 사용할 수 있으며, 메모리 순서에 중요한 영향을 미칩니다.

/* LOCK의 메모리 순서 보장 */
/* LOCK 접두사가 있는 명령어는 다음을 보장:
 * 1. Full memory barrier (read+write 양방향)
 * 2. 원자적 read-modify-write
 * 3. 캐시 라인 단위 잠금 (MESI 프로토콜)
 *
 * 따라서 LOCK ADD는 MFENCE와 동등한 순서 보장:
 * → smp_mb() 구현에 LOCK ADD 사용 (MFENCE보다 빠름) */

/* arch/x86/include/asm/barrier.h */
#define __smp_mb()  asm volatile("lock; addl $0,-4(%%rsp)" ::: "memory", "cc")
/* 스택 최상위에 0을 더함 (무효 연산) → 부작용은 full barrier */

/* 허용되지 않는 명령어에 LOCK 사용 시 → #UD 예외 */
/* 예: LOCK MOV → Undefined Opcode */

Per-CPU 변수 접근 어셈블리

Linux 커널의 Per-CPU 변수는 캐시 경합 없이 CPU별 데이터를 관리합니다. x86_64에서는 %gs 세그먼트 베이스를 활용하여 단일 명령어로 현재 CPU의 데이터에 접근합니다.

Per-CPU 연산 인라인 어셈블리

/* arch/x86/include/asm/percpu.h — this_cpu_* 연산 */

/* this_cpu_read: GS 세그먼트로 직접 읽기 */
#define this_cpu_read_8(pcp) ({                          \
    u64 __val;                                            \
    asm volatile ("movq %%gs:%1, %0"                    \
                 : "=r" (__val)                            \
                 : "m" (pcp));                              \
    __val;                                                  \
})

/* this_cpu_add: GS 세그먼트 + 원자적 덧셈 (IRQ 안전) */
#define this_cpu_add_8(pcp, val) do {                     \
    asm volatile ("addq %1, %%gs:%0"                    \
                 : "+m" (pcp)                              \
                 : "re" ((u64)(val)));                    \
} while (0)

/* this_cpu_cmpxchg: GS 세그먼트 + CMPXCHG */
#define this_cpu_cmpxchg_8(pcp, old, new) ({             \
    u64 __ret;                                            \
    asm volatile ("cmpxchgq %2, %%gs:%1"               \
                 : "=a" (__ret), "+m" (pcp)               \
                 : "r" ((u64)(new)), "0" ((u64)(old))     \
                 : "memory");                               \
    __ret;                                                  \
})

/* 주요 Per-CPU 변수 (커널에서 가장 자주 접근) */
/* current_task    — 현재 실행 중인 태스크 */
/* cpu_number      — 현재 CPU 번호 */
/* irq_count       — 인터럽트 중첩 카운터 */
/* __preempt_count — 선점 카운터 */
/* cpu_tlbstate     — TLB 상태 */
/* gdt_page        — Per-CPU GDT */

/* 'current' 매크로 = this_cpu_read(current_task) */
/* → movq %gs:current_task, %rax (단일 명령어!) */

AT&T vs Intel 문법 비교

x86 어셈블리에는 두 가지 주요 문법이 있습니다. Linux 커널과 GCC는 기본적으로 AT&T 문법을 사용하지만, Intel 문법도 지원합니다. 두 문법의 핵심 차이를 이해하는 것이 중요합니다.

x86 명령어 인코딩

커널 어셈블리를 디버깅하거나 바이너리 패칭(ALTERNATIVE, static key)을 이해하려면 x86 명령어의 바이트 수준 인코딩을 알아야 합니다. REX, VEX, EVEX 접두사와 ModRM/SIB 바이트 구조를 이해하면 objdump 출력을 정확히 해석할 수 있습니다.

레거시 접두사

LOCK 접두사와 버스 동작

/* LOCK 접두사의 하드웨어 동작 */
/*                                                                     */
/* 현대 CPU (Intel Nehalem+):                                          */
/*   캐시 라인이 단일 코어에 있으면 → 캐시 락 (MESI Exclusive/Modified) */
/*   캐시 라인을 넘거나 UC 메모리 → 버스 락 (전체 메모리 접근 차단)     */
/*                                                                     */
/* LOCK은 암묵적 full memory barrier (mfence와 동등)                   */

/* LOCK 허용 명령어 (이외 명령어에 LOCK 사용 시 #UD 예외) */
/* ADD, ADC, AND, BTC, BTR, BTS, CMPXCHG, CMPXCHG8B/16B, */
/* DEC, INC, NEG, NOT, OR, SBB, SUB, XOR, XADD, XCHG     */

/* XCHG는 암묵적 LOCK (접두사 불필요) */
xchg %rax, (%rbx)            /* 항상 atomic, 항상 full barrier */

/* 커널에서의 LOCK 사용 */
static inline void atomic_inc(atomic_t *v)
{
    asm volatile (LOCK_PREFIX "incl %0"
                 : "+m" (v->counter));
}

/* SMP에서만 LOCK: UP에서는 nop */
#ifdef CONFIG_SMP
#define LOCK_PREFIX "lock ; "
#else
#define LOCK_PREFIX ""
#endif

NOP 인코딩과 패칭

커널의 ALTERNATIVE, static key, ftrace 모두 특정 길이의 NOP으로 코드를 채우고 런타임에 패칭합니다. Intel은 다양한 길이의 NOP 인코딩을 제공합니다.

REX 접두사 상세 비트 레이아웃

REX 접두사(0x40-0x4F)는 64비트 모드에서 레지스터 확장과 64비트 오퍼랜드 크기를 위해 사용됩니다.

VEX 접두사 2/3바이트 상세

VEX(Vector Extensions) 접두사는 AVX 명령어에 사용되며, 레거시 접두사(66/F2/F3)와 REX를 대체합니다.

/* VEX 필드 설명:
 * pp: 00=없음, 01=66, 10=F3, 11=F2 (레거시 접두사 대체)
 * mmmmm: 00001=0F, 00010=0F38, 00011=0F3A (opcode 맵)
 * vvvv: 추가 소스 레지스터 (비파괴적 3-operand)
 * L: 0=128비트(XMM), 1=256비트(YMM)
 * W: 0=32비트, 1=64비트 (opcode에 따라 다른 의미)
 * R̃X̃B̃: REX.RXB의 반전 (1의 보수) */

/* 예: vaddpd %ymm2, %ymm1, %ymm0 */
/* C5 F5 58 C2 */
/* C5: 2-byte VEX prefix */
/* F5: R̃=1(reg=ymm0), vvvv=1110(~ymm1=ymm1), L=1(256bit), pp=01(66) */
/* 58: ADDPD opcode */
/* C2: ModRM: mod=11 reg=000(ymm0) rm=010(ymm2) */

EVEX 4바이트 접두사 상세

EVEX(Enhanced VEX)는 AVX-512 명령어에 사용되며, 마스킹, 브로드캐스트, 512비트 벡터를 지원합니다.

Opcode 맵 (1/2/3바이트)

인코딩 실전 연습

커널에서 자주 사용하는 명령어 5개를 바이트 수준에서 분석합니다.

/* 1. mov %rax, %rbx → 48 89 C3 */
/*    48: REX.W (64비트 오퍼랜드) */
/*    89: MOV r/m, r opcode */
/*    C3: ModRM = 11 000 011 → mod=11(reg) reg=000(rax) rm=011(rbx) */

/* 2. lock cmpxchg %rcx, (%rdx) → F0 48 0F B1 0A */
/*    F0: LOCK 접두사 */
/*    48: REX.W (64비트) */
/*    0F B1: CMPXCHG opcode */
/*    0A: ModRM = 00 001 010 → mod=00(mem) reg=001(rcx) rm=010(rdx) */

/* 3. movq $0x12345678, %rdi → 48 C7 C7 78 56 34 12 */
/*    48: REX.W (64비트) */
/*    C7: MOV r/m, imm32 opcode */
/*    C7: ModRM = 11 000 111 → mod=11(reg) reg=000(/0) rm=111(rdi) */
/*    78 56 34 12: imm32 (리틀 엔디안, 부호 확장 → 64비트) */

/* 4. addl $1, %gs:0x10(%rbx) → 65 83 43 10 01 */
/*    65: GS 세그먼트 접두사 (Per-CPU) */
/*    83: ADD r/m, imm8 opcode */
/*    43: ModRM = 01 000 011 → mod=01(mem+disp8) reg=000(/0) rm=011(rbx) */
/*    10: disp8 = 0x10 */
/*    01: imm8 = 1 */

/* 5. jmp *%rax → FF E0 */
/*    FF: JMP r/m64 opcode */
/*    E0: ModRM = 11 100 000 → mod=11(reg) reg=100(/4 JMP) rm=000(rax) */
/*    참고: 64비트 모드에서 REX.W 불필요 (기본 64비트) */

GNU Assembler (GAS) 지시자

GNU Assembler는 Linux 커널의 어셈블리 파일(.S)을 처리합니다. 자주 사용되는 GAS 지시자를 이해해야 커널의 어셈블리 코드를 읽을 수 있습니다. 지시자 전체 참조와 CFI 지시자, 커맨드라인 옵션, 아키텍처별 확장은 GNU Assembler (as) 완전 가이드를 참고하세요.

섹션 지시자

.section .text            /* 코드 섹션 (실행 가능) */
.section .data            /* 초기화된 데이터 */
.section .bss             /* 초기화되지 않은 데이터 */
.section .rodata          /* 읽기 전용 데이터 */
.section .init.text, "ax" /* 초기화 코드 (부팅 후 해제) */

/* 커널 전용 섹션 예시 */
.pushsection .altinstructions, "a"   /* 대안 명령어 섹션 */
.popsection                          /* 이전 섹션으로 복귀 */

심볼과 정렬

.global  my_function      /* 전역 심볼 선언 */
.local   helper_func      /* 로컬 심볼 (외부 비공개) */
.type    my_function, @function  /* 함수 타입 정보 */
.size    my_function, . - my_function  /* 함수 크기 */

.align   16               /* 16바이트 정렬 */
.balign  4096             /* 4096바이트 경계 정렬 */
.p2align 4                /* 2^4 = 16바이트 정렬 */

매크로와 조건부 어셈블리

/* 매크로 정의 */
.macro SAVE_REGS
    pushq   %rbp
    pushq   %rbx
    pushq   %r12
    pushq   %r13
    pushq   %r14
    pushq   %r15
.endm

.macro RESTORE_REGS
    popq    %r15
    popq    %r14
    popq    %r13
    popq    %r12
    popq    %rbx
    popq    %rbp
.endm

/* 매크로 매개변수 */
.macro PUSH_AND_CLEAR reg:req
    pushq   \reg
    xorq    \reg, \reg
.endm

/* 조건부 어셈블리 */
.if CONFIG_X86_64
    movq    %rsp, %rdi
.else
    movl    %esp, %eax
.endif

/* 반복 */
.rept 8
    nop                      /* 8번 반복 */
.endr

데이터 지시자

.byte    0x90             /* 1바이트 */
.word    0x1234           /* 2바이트 */
.long    0x12345678       /* 4바이트 */
.quad    0x123456789abcdef0 /* 8바이트 */
.ascii   "Hello"          /* 문자열 (NUL 없음) */
.asciz   "Hello"          /* NUL 종료 문자열 */
.fill    256, 1, 0        /* 256바이트를 0으로 채움 */
.space   4096             /* 4096바이트 공간 확보 */

/* 커널에서 자주 보는 SYM_* 매크로 (include/linux/linkage.h) */
SYM_FUNC_START(my_asm_func)     /* 함수 시작 선언 */
    /* ... 코드 ... */
    retq
SYM_FUNC_END(my_asm_func)       /* 함수 종료 + 크기 기록 */

SYM_CODE_START(entry_point)      /* 비표준 호출 규약 코드 */
SYM_CODE_END(entry_point)

SYM_DATA_START(my_data)          /* 데이터 심볼 */
    .long 42
SYM_DATA_END(my_data)

CFI 지시자 (DWARF 언와인드 정보)

CFI(Call Frame Information) 지시자는 DWARF 언와인드 정보를 생성합니다. 스택 트레이스, 예외 처리, perf callchain에 필수입니다. 커널에서는 SYM_FUNC_START/SYM_FUNC_END가 내부적으로 CFI 지시자를 포함합니다. CFI 지시자 전체 참조(25개)는 GNU Assembler — CFI 지시자 섹션을 참고하세요.

.cfi_startproc              /* 함수 시작 — CFI 정보 블록 시작 */
    pushq   %rbp
    .cfi_def_cfa_offset 16  /* CFA = rsp + 16 */
    .cfi_offset %rbp, -16   /* saved rbp는 CFA-16 위치 */
    movq    %rsp, %rbp
    .cfi_def_cfa_register %rbp  /* CFA 기준 레지스터를 rbp로 변경 */
    /* ... 함수 본문 ... */
    leave
    .cfi_def_cfa %rsp, 8    /* 복귀: CFA = rsp + 8 */
    ret
.cfi_endproc                /* CFI 정보 블록 종료 */

.altmacro 모드

.altmacro는 GAS의 대체 매크로 모드로, 문자열 조작과 수식 평가 기능을 확장합니다.

.altmacro

/* LOCAL: 고유 레이블 생성 */
.macro SAVE_REG reg
    LOCAL label_done
    push \reg
    test \reg, \reg
    jz label_done
    /* ... 추가 처리 ... */
label_done:
.endm

/* 꺾쇠 괄호 문자열과 수식 */
.macro ENTRY_N n
    .globl entry_\n
    entry_\n:
    push %(8*\n)(%rsp)     /* 수식 평가: offset = 8*n */
.endm

/* % 연산자로 수식을 텍스트로 변환 */
.macro DEFINE_ISR num
    SYM_CODE_START(isr_%num)
    pushq $%num              /* 즉시값으로 벡터 번호 */
    jmp common_interrupt
    SYM_CODE_END(isr_%num)
.endm

.irp / .irpc 반복 지시자

커널은 .irp와 .irpc로 레지스터 저장/복원 등 반복 코드를 생성합니다.

/* .irp: 값 목록 반복 */
.irp reg, rax, rbx, rcx, rdx, rsi, rdi, r8, r9, r10, r11, r12, r13, r14, r15
    pushq %\reg
.endr

/* 커널 entry 코드에서 pt_regs 저장에 활용 */
/* arch/x86/entry/calling.h */
.macro PUSH_AND_CLEAR_REGS rdx=%rdx rcx=%rcx rax=%rax save_ret=0
    pushq %rdi
    pushq %rsi
    pushq \rdx
    pushq \rcx
    pushq \rax
    pushq %r8
    pushq %r9
    pushq %r10
    pushq %r11
    pushq %rbx
    pushq %rbp
    pushq %r12
    pushq %r13
    pushq %r14
    pushq %r15
    /* XOR로 레지스터 클리어 (정보 누출 방지) */
    xorl %edx, %edx
    xorl %ecx, %ecx
    ...
.endm

조건부 어셈블리 심화

커널 어셈블리 파일은 C 전처리기와 GAS 조건부 지시자를 모두 활용합니다.

/* C 전처리기 (#ifdef) — .S 파일은 cpp 통과 */
#ifdef CONFIG_SMP
    lock
#endif
    addl $1, (%rdi)

/* GAS 조건부 어셈블리 */
.ifdef HAVE_FEATURE_X
    /* 피처 X 활용 코드 */
.else
    /* 폴백 코드 */
.endif

/* .if: 수식 기반 조건 */
.if (\size == 8)
    movq (%rsi), %rax
.elseif (\size == 4)
    movl (%rsi), %eax
.elseif (\size == 2)
    movw (%rsi), %ax
.else
    movb (%rsi), %al
.endif

/* .ifc: 문자열 비교 */
.ifc \reg, rsp
    .error "RSP는 사용할 수 없습니다"
.endif

CFI와 스택 해제

CFI(Call Frame Information) 지시자는 DWARF 디버깅 정보의 핵심으로, 스택 트레이스와 예외 처리에 필수입니다. 커널은 DWARF CFI 외에 자체적인 ORC 언와인더를 사용합니다.

DWARF CFI 지시자 상세

/* 전형적인 함수 프롤로그/에필로그 CFI */
my_function:
.cfi_startproc
    /* 초기 CFA: RSP + 8 (복귀 주소) */
    pushq %rbp
    .cfi_def_cfa_offset 16    /* CFA = RSP + 16 */
    .cfi_offset %rbp, -16     /* RBP가 CFA-16에 저장됨 */
    movq %rsp, %rbp
    .cfi_def_cfa_register %rbp /* CFA = RBP + 16 */

    pushq %rbx
    .cfi_offset %rbx, -24     /* RBX가 CFA-24에 저장됨 */
    pushq %r12
    .cfi_offset %r12, -32     /* R12가 CFA-32에 저장됨 */
    subq $16, %rsp            /* 지역 변수 공간 */

    /* ... 함수 본문 ... */

    addq $16, %rsp
    popq %r12
    .cfi_restore %r12
    popq %rbx
    .cfi_restore %rbx
    popq %rbp
    .cfi_restore %rbp
    .cfi_def_cfa %rsp, 8
    ret
.cfi_endproc

ORC 언와인더

커널은 DWARF 대신 ORC(Oops Rewind Capability) 형식을 사용합니다. DWARF보다 빠르고 단순하며, objtool이 자동 생성합니다.

/* ORC 엔트리 구조 — arch/x86/include/asm/orc_types.h */
struct orc_entry {
    s16 sp_offset;     /* CFA에서 SP까지 오프셋 */
    s16 bp_offset;     /* CFA에서 BP까지 오프셋 */
    unsigned sp_reg:4; /* CFA 기준 레지스터 (SP/BP/등) */
    unsigned bp_reg:4; /* BP 저장 위치 레지스터 */
    unsigned type:3;   /* CALL/REGS/IRET 타입 */
    unsigned signal:1; /* 시그널 프레임 여부 */
}; /* 총 6바이트 */

/* .orc_unwind_ip: IP → ORC 엔트리 매핑 (상대 주소, 4바이트씩)
 * .orc_unwind:    ORC 엔트리 배열 (6바이트씩)
 * → IP로 이진 검색 → 해당 ORC 엔트리 → CFA 계산 → 스택 해제 */

.eh_frame vs .debug_frame

스택 해제 과정 단계별

x86_64 호출 규약 심화

Linux 커널은 x86_64에서 System V AMD64 ABI를 따릅니다. 함수 호출 시 레지스터 사용 규칙을 정확히 알아야 합니다.

레지스터 역할

스택 프레임과 Red Zone

/*
 * 표준 함수 프롤로그/에필로그
 *
 * 스택 레이아웃:
 *   [rbp+16]  두 번째 스택 인자 (있는 경우)
 *   [rbp+8]   리턴 주소
 *   [rbp]     이전 rbp (프레임 포인터)
 *   [rbp-8]   로컬 변수 시작
 */
SYM_FUNC_START(example_func)
    pushq   %rbp                /* 프레임 포인터 저장 */
    movq    %rsp, %rbp          /* 새 프레임 설정 */
    subq    $32, %rsp           /* 로컬 변수 공간 */
    pushq   %rbx                /* callee-saved 보존 */
    pushq   %r12

    /* ... 함수 본문 ... */

    popq    %r12                /* callee-saved 복원 */
    popq    %rbx
    leave                       /* = movq %rbp,%rsp; popq %rbp */
    retq
SYM_FUNC_END(example_func)

시스템 콜 vs 일반 함수 호출

Windows x64 ABI 비교

Windows x64 호출 규약은 System V ABI와 크게 다릅니다. UEFI 펌웨어나 크로스 플랫폼 코드를 이해할 때 필요합니다.

가변 인자 (Variadic) 어셈블리

System V ABI에서 가변 인자 함수는 AL 레지스터에 사용된 벡터 레지스터 수를 전달합니다.

/* 가변 인자 호출 시 AL = 벡터 레지스터 수 */
/* printf("%.2f %d", 3.14, 42) 호출 시: */
/*   RDI = format string pointer */
/*   XMM0 = 3.14 (double) */
/*   RSI = 42 */
/*   AL = 1 (SSE 레지스터 1개 사용) */

/* va_list 구조 (System V ABI) */
typedef struct {
    unsigned int gp_offset;    /* 다음 GP 레지스터 오프셋 */
    unsigned int fp_offset;    /* 다음 FP 레지스터 오프셋 */
    void *overflow_arg_area;   /* 스택 오버플로 인자 */
    void *reg_save_area;       /* 레지스터 저장 영역 */
} va_list[1];
/* 프롤로그에서 RDI,RSI,RDX,RCX,R8,R9와 XMM0-XMM7을 저장 */

Red Zone 상세와 커널 금지 이유

System V ABI의 Red Zone은 RSP 아래 128바이트를 함수가 자유롭게 사용할 수 있는 영역입니다. 커널에서는 반드시 비활성화(-mno-red-zone)해야 합니다.

/* Red Zone: RSP 아래 128바이트 */
/*
 * ┌──────────────────┐ ← RSP
 * │                  │
 * │   Red Zone       │  128바이트
 * │   (함수가 사용)   │  스택 조정 없이 사용 가능
 * │                  │
 * └──────────────────┘ ← RSP - 128
 *
 * 리프 함수(다른 함수 호출 안 하는)에서 활용:
 * - SUB RSP 없이 지역변수 사용 가능
 * - 성능 이점: 스택 포인터 조정 명령어 절약
 */

/* 커널에서 금지하는 이유:
 * 1. 인터럽트가 현재 스택에 데이터 푸시
 *    → Red Zone 내용 덮어씀 → 데이터 손상
 * 2. NMI가 언제든 발생 가능
 *    → 스택에 즉시 쓰기 → Red Zone 파괴
 * 3. 예외(#PF, #GP)가 스택에 에러코드 푸시
 *
 * 커널 빌드 플래그:
 * KBUILD_CFLAGS += -mno-red-zone
 */

커널 SIMD/FPU 어셈블리

Linux 커널은 성능이 중요한 경로(암호화, RAID, 체크섬, 문자열 연산)에서 SIMD/FPU 명령어를 사용합니다. 커널 모드에서 FPU를 사용하려면 kernel_fpu_begin()/kernel_fpu_end()로 FPU 상태를 보호해야 하며, XSAVE/XRSTOR 메커니즘을 이해해야 합니다.

kernel_fpu_begin/end 사용 패턴

/* arch/x86/crypto/aesni-intel_glue.c — AES-NI 사용 예 */
static int aesni_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
{
    struct crypto_aes_ctx *ctx = crypto_tfm_ctx(tfm);

    if (!irq_fpu_usable()) {
        /* 인터럽트 컨텍스트 → 소프트웨어 폴백 */
        aes_encrypt(ctx, dst, src);
        return 0;
    }

    kernel_fpu_begin();           /* 선점 비활성 + FPU 상태 저장 */
    aesni_enc(ctx, dst, src);     /* AES-NI 어셈블리 호출 */
    kernel_fpu_end();             /* FPU 상태 복원 + 선점 활성 */
    return 0;
}

/* arch/x86/crypto/aesni-intel_asm.S — AES-NI 어셈블리 (핵심) */
SYM_FUNC_START(aesni_enc)
    movups  (%rsi), %xmm0        /* 평문 로드 → XMM0 */
    movups  (%rdi), %xmm1        /* 라운드 키 0 */
    pxor    %xmm1, %xmm0         /* AddRoundKey */

    /* 9~13 라운드 (키 크기에 따라) */
    movups  0x10(%rdi), %xmm1
    aesenc  %xmm1, %xmm0         /* AES-NI: 단일 라운드 암호화 */
    movups  0x20(%rdi), %xmm1
    aesenc  %xmm1, %xmm0
    /* ... 반복 ... */

    movups  0xa0(%rdi), %xmm1
    aesenclast %xmm1, %xmm0      /* 최종 라운드 */
    movups  %xmm0, (%rdx)         /* 암호문 저장 */
    RET
SYM_FUNC_END(aesni_enc)

XSAVE/XRSTOR 메커니즘

/* FPU/SIMD 상태 저장/복원 — arch/x86/include/asm/fpu/internal.h */

/* XSAVE: XCR0에 설정된 컴포넌트만 저장 */
static inline void xsave(struct fpu *fpu)
{
    u64 mask = fpu->state_mask;
    asm volatile (
        "xsaveopt %[buf]"       /* 수정된 컴포넌트만 저장 (최적화) */
        : [buf] "=m" (fpu->fpstate->regs)
        : "a" ((u32)mask), "d" ((u32)(mask >> 32))
        : "memory"
    );
}

/* XRSTOR: 저장된 컴포넌트 복원 */
static inline void xrstor(struct fpu *fpu)
{
    u64 mask = fpu->state_mask;
    asm volatile (
        "xrstor %[buf]"
        :: [buf] "m" (fpu->fpstate->regs),
           "a" ((u32)mask), "d" ((u32)(mask >> 32))
        : "memory"
    );
}

/* XCR0 비트 (활성 컴포넌트) */
/* bit 0: x87 FPU         (필수, 항상 1) */
/* bit 1: SSE (XMM0-15)   (128비트) */
/* bit 2: AVX (YMM0-15)   (256비트 상위 절반) */
/* bit 5: AVX-512 opmask  (k0-k7 마스크 레지스터) */
/* bit 6: AVX-512 ZMM_Hi  (ZMM0-15 상위 256비트) */
/* bit 7: AVX-512 Hi-ZMM  (ZMM16-31 전체) */
/* bit 9: PKRU             (Protection Key) */
/* bit 17-18: AMX          (타일 구성/데이터) */

RAID XOR / P+Q SIMD 어셈블리

/* lib/raid6/avx2.c — AVX2 RAID6 P+Q 계산 */
/* P = 단순 XOR, Q = GF(2^8) 곱셈 + XOR */

SYM_FUNC_START(raid6_avx2x2_gen_syndrome)
    kernel_fpu_begin_mask(KFPU_256BIT)

    /* YMM 레지스터로 256비트 (32바이트) 동시 처리 */
    vmovdqa  (%rdi), %ymm0       /* 디스크 데이터 32B 로드 */
    vmovdqa  32(%rdi), %ymm1     /* 다음 32B */

    vpxor    %ymm0, %ymm4, %ymm4 /* P ^= data */
    vpxor    %ymm1, %ymm5, %ymm5

    /* Q 계산: GF(2^8) 곱셈 = shift + conditional XOR */
    vpcmpgtb %ymm6, %ymm2, %ymm3 /* MSB 검사 → 마스크 */
    vpaddb   %ymm2, %ymm2, %ymm2 /* Q <<= 1 */
    vpand    %ymm7, %ymm3, %ymm3 /* 마스크 & 0x1d (다항식) */
    vpxor    %ymm3, %ymm2, %ymm2 /* Q ^= polynomial */
    vpxor    %ymm0, %ymm2, %ymm2 /* Q ^= data */
    /* ... */

    kernel_fpu_end()
SYM_FUNC_END(raid6_avx2x2_gen_syndrome)

AVX-512 커널 활용 예시

AVX-512는 512비트(64바이트) 벡터 연산을 제공하며, 커널에서는 RAID 패리티 연산, 암호화 가속, 체크섬 계산에 활용됩니다.

/* RAID6 P+Q 패리티: AVX-512 — arch/x86/lib/raid6/avx512.c */
/* kernel_fpu_begin() 호출 후 사용 */

    /* 512비트 XOR: P 패리티 */
    vmovdqa64  (%rsi), %zmm0        /* 디스크 1 데이터 (64B) */
    vpxorq     (%rdx), %zmm0, %zmm0 /* XOR 디스크 2 */
    vpxorq     (%rcx), %zmm0, %zmm0 /* XOR 디스크 3 */
    vmovdqa64  %zmm0, (%rdi)        /* P 패리티 저장 */

    /* 3-way 논리 연산: VPTERNLOGD (진리표 기반) */
    vpternlogd $0x96, %zmm2, %zmm1, %zmm0
    /* imm8=0x96 = XOR(a,b,c): P = D1 ^ D2 ^ D3 */
    /* VPTERNLOGD 한 명령어로 3-way XOR 완료 */

    /* opmask 사용 예: 조건부 연산 */
    vpcmpd    $4, %zmm1, %zmm0, %k1  /* k1 = zmm0 != zmm1 */
    vmovdqa32 %zmm2, %zmm0{%k1}      /* k1 마스크: 다른 원소만 업데이트 */

AMX (Advanced Matrix Extensions) 개요

Intel AMX는 행렬(타일) 연산을 위한 확장으로, AI/ML 추론 가속에 사용됩니다. Sapphire Rapids 이후 서버 CPU에서 지원합니다.

/* AMX 사용 패턴 (커널 내부) */
/* AMX 타일 데이터는 XSAVE/XRSTOR로 관리 */
/* 커널은 XFD(Extended Feature Disable)로 첫 사용 시 lazy 할당 */

/* AMX 타일 설정 */
struct tile_config {
    u8 palette_id;       /* 타일 팔레트 (1) */
    u8 start_row;        /* 재시작 행 */
    u8 reserved[14];
    u16 colsb[8];        /* 각 타일의 열 수 (바이트) */
    u8 padding[16];
    u8 rows[8];          /* 각 타일의 행 수 */
    u8 padding2[8];
} __packed;  /* 총 64바이트 */

/* LDTILECFG: 타일 설정 로드 */
asm volatile ("ldtilecfg (%0)" : : "r"(&config) : "memory");

/* TILELOADD: 타일 데이터 로드 (행렬) */
/* TDPBSSD: 타일 곱셈-덧셈 (int8 → int32) */
/* TILESTORED: 결과 저장 */
/* TILERELEASE: 타일 해제 (INIT 상태로) */

ARM64 어셈블리

Linux 커널은 ARM64 (AArch64)도 광범위하게 지원합니다. ARM64 어셈블리의 기본을 알면 멀티 아키텍처 코드를 이해하는 데 도움이 됩니다.

ARM64 레지스터

ARM64 주요 명령어

/* 산술 연산 */
add     x0, x1, x2              /* x0 = x1 + x2 */
sub     x0, x1, #16             /* x0 = x1 - 16 */
madd    x0, x1, x2, x3          /* x0 = x1*x2 + x3 */

/* 메모리 접근: LDP/STP (쌍 로드/저장) */
stp     x29, x30, [sp, #-16]!  /* FP, LR 스택에 저장 (pre-index) */
ldp     x29, x30, [sp], #16    /* FP, LR 복원 (post-index) */

/* 조건부 실행 */
cmp     x0, #0
csel    x1, x2, x3, eq          /* if (x0==0) x1=x2 else x1=x3 */
cset    x0, ne                   /* x0 = (조건 NE이면 1, 아니면 0) */

/* PC 상대 주소 계산 */
adrp    x0, my_symbol            /* x0 = 페이지 주소 (4KB 정렬) */
add     x0, x0, :lo12:my_symbol  /* 하위 12비트 오프셋 추가 */

/* 비트 조작 */
ubfx    x0, x1, #4, #8         /* x1의 비트[11:4] 추출 → x0 */
bfi     x0, x1, #8, #4         /* x1의 하위 4비트를 x0[11:8]에 삽입 */

ARM64 커널 어셈블리 예시

/* ARM64 인라인 어셈블리: 현재 Exception Level 읽기 */
static inline u64 read_currentel(void)
{
    u64 val;
    asm volatile ("mrs %0, CurrentEL" : "=r"(val));
    return (val >> 2) & 3;  /* EL0=0, EL1=1, EL2=2 */
}

/* ARM64 인라인 어셈블리: 데이터 캐시 클린 + 무효화 */
static inline void dc_civac(unsigned long addr)
{
    asm volatile ("dc civac, %0" :: "r"(addr) : "memory");
}

/* ARM64 인라인 어셈블리: 명령어 배리어 */
static inline void isb(void)
{
    asm volatile ("isb" ::: "memory");
}

ARM64 인라인 어셈블리

ARM64(AArch64) GCC 인라인 어셈블리는 x86과 다른 제약조건과 레지스터 참조 규칙을 사용합니다.

/* ARM64 인라인 어셈블리 레지스터 참조 */
u64 val;
asm volatile ("mrs %0, cntvct_el0" : "=r"(val));
/* %0 → x 레지스터 (64비트), %w0 → w 레지스터 (32비트) */

/* 시스템 레지스터 읽기/쓰기 */
static inline u64 read_sysreg(void)
{
    u64 val;
    asm volatile ("mrs %0, sctlr_el1" : "=r"(val));
    return val;
}

/* 32비트 레지스터 접근 (%w 접두사) */
u32 lo;
asm volatile ("mrs %w0, cntfrq_el0" : "=r"(lo));
/* %w0 = w 레지스터 (32비트 하위), %x0 = x 레지스터 (64비트) */

/* 메모리 배리어와 결합 */
asm volatile ("dmb ish" ::: "memory");
asm volatile ("dsb sy" ::: "memory");
asm volatile ("isb" ::: "memory");

ARM64 조건 코드

ARM64는 NZCV(Negative, Zero, Carry, oVerflow) 플래그를 사용하며, 조건부 선택 명령어로 분기 없이 조건부 실행을 구현합니다.

/* ARM64 조건부 선택 명령어 — 분기 없는 조건부 실행 */
    cmp  x0, x1
    csel x2, x3, x4, gt   /* x2 = (x0 > x1) ? x3 : x4 */
    csinc x2, x3, x4, eq  /* x2 = (x0 == x1) ? x3 : x4+1 */
    csinv x2, x3, x4, ne  /* x2 = (x0 != x1) ? x3 : ~x4 */
    csneg x2, x3, x4, lt  /* x2 = (x0 < x1) ? x3 : -x4 */

/* x86 CMOV 등가:
 * x86: cmovg %ecx, %eax  → 조건부 이동
 * arm64: csel x0, x1, x0, gt → 더 유연 (두 소스 선택)
 *
 * ARM64 CSEL은 x86 CMOV보다 유연:
 *  - 두 개의 서로 다른 소스 레지스터 선택 가능
 *  - CSINC/CSINV/CSNEG로 산술 변환 결합 가능
 */

RISC-V 어셈블리

RISC-V는 오픈 ISA로 Linux 커널에서 지원이 빠르게 확대되고 있습니다. x86/ARM64와 다른 설계 철학(최소 명령어, CSR 기반 시스템 제어, 확장 모듈형)을 이해하면 멀티 아키텍처 커널 코드를 효과적으로 읽을 수 있습니다.

RISC-V 주요 명령어 패턴

/* RISC-V 기본 명령어 (RV64I) */

/* 산술/논리 */
add   a0, a1, a2       /* a0 = a1 + a2 */
addi  a0, a1, 42       /* a0 = a1 + 42 */
addw  a0, a1, a2       /* 32비트 덧셈 (W 접미사) */
slli  a0, a1, 3        /* a0 = a1 << 3 */
and   a0, a1, a2       /* a0 = a1 & a2 */

/* 메모리 접근 (Load/Store만 — RISC 원칙) */
ld    a0, 0(sp)        /* 64비트 load */
lw    a0, 4(sp)        /* 32비트 load (부호 확장) */
lwu   a0, 4(sp)        /* 32비트 load (제로 확장) */
lb    a0, 0(a1)        /* 1바이트 load */
sd    a0, 0(sp)        /* 64비트 store */
sw    a0, 4(sp)        /* 32비트 store */

/* 분기 */
beq   a0, a1, label    /* a0 == a1 이면 점프 */
bne   a0, zero, label  /* a0 != 0 이면 점프 */
blt   a0, a1, label    /* a0 < a1 (부호) 이면 점프 */
bltu  a0, a1, label    /* a0 < a1 (비부호) 이면 점프 */

/* 함수 호출 */
jal   ra, func         /* call: ra에 복귀 주소 저장, func로 점프 */
jalr  zero, ra, 0      /* ret: ra로 복귀 (rd=zero이면 반환값 없음) */

/* 큰 상수 로딩 */
lui   a0, %hi(symbol)  /* 상위 20비트 로드 */
addi  a0, a0, %lo(symbol) /* 하위 12비트 추가 */

/* PC 상대 주소 */
auipc a0, %pcrel_hi(sym) /* a0 = PC + (상위 20비트 << 12) */
addi  a0, a0, %pcrel_lo(sym)

RISC-V Atomic 확장 (A)

/* RV64A — Atomic Memory Operations */

/* Load-Reserved / Store-Conditional (LL/SC 패턴) */
/* ARM의 LDXR/STXR, MIPS의 LL/SC와 유사 */
.Lretry:
    lr.d    a0, (a1)           /* load-reserved: a0 = *a1, 예약 세트 */
    add     a2, a0, a3         /* 새 값 계산 */
    sc.d    a4, a2, (a1)       /* store-conditional: *a1 = a2, a4=성공(0)/실패(!=0) */
    bnez    a4, .Lretry        /* 실패하면 재시도 */

/* AMO (Atomic Memory Operations) — 단일 명령어 atomic */
amoadd.d  a0, a1, (a2)        /* a0 = *a2; *a2 += a1 (atomic) */
amoswap.d a0, a1, (a2)        /* a0 = *a2; *a2 = a1 (atomic swap) */
amoand.d  a0, a1, (a2)        /* a0 = *a2; *a2 &= a1 */
amoor.d   a0, a1, (a2)        /* a0 = *a2; *a2 |= a1 */
amomax.d  a0, a1, (a2)        /* a0 = *a2; *a2 = max(*a2, a1) */

/* 메모리 순서 접미사: .aq (acquire), .rl (release), .aqrl (both) */
amoadd.d.aqrl a0, a1, (a2)    /* full barrier atomic add */
lr.d.aq   a0, (a1)            /* acquire load-reserved */
sc.d.rl   a0, a1, (a2)        /* release store-conditional */

RISC-V 커널 어셈블리 예시

/* arch/riscv/kernel/entry.S — 시스템 콜 / 트랩 진입 */
SYM_CODE_START(handle_exception)
    /* 1. 커널 스택으로 전환 (sscratch ↔ sp 교환) */
    csrrw   sp, sscratch, sp   /* sscratch에 유저 sp 저장, 커널 sp 로드 */

    /* 유저에서 왔는지 확인 */
    bnez    sp, .Lsave_context /* sp != 0 → 유저 모드 (sscratch에 커널 sp 저장됨) */
    csrr    sp, sscratch       /* sp == 0 → 이미 커널 모드, sp 복원 */

.Lsave_context:
    /* 2. pt_regs 구조체 저장 */
    addi    sp, sp, -(PT_SIZE) /* pt_regs 크기만큼 스택 확보 */
    sd      x1, PT_RA(sp)      /* ra 저장 */
    sd      x3, PT_GP(sp)      /* gp 저장 */
    sd      x5, PT_T0(sp)      /* t0 저장 */
    /* ... 나머지 레지스터 저장 ... */
    sd      x10, PT_A0(sp)     /* a0 (syscall 첫 인자) */
    sd      x17, PT_A7(sp)     /* a7 (syscall 번호) */

    /* 3. CSR 저장 */
    csrr    s1, sepc           /* 예외 발생 PC */
    csrr    s2, sstatus        /* 상태 레지스터 */
    csrr    s3, stval          /* 트랩 값 (fault 주소 등) */
    csrr    s4, scause         /* 트랩 원인 */
    sd      s1, PT_EPC(sp)
    sd      s2, PT_STATUS(sp)

    /* 4. 트랩 원인 분기 */
    blt     s4, zero, .Lhandle_interrupt  /* scause < 0 → 인터럽트 */
    /* scause >= 0 → 예외 (syscall: cause=8, page fault: cause=13/15) */

    li      t0, EXC_SYSCALL    /* cause == 8? */
    beq     s4, t0, .Lhandle_syscall
    /* 기타 예외 처리... */

.Lhandle_syscall:
    addi    s1, s1, 4          /* sepc += 4 (ecall 다음 명령어) */
    sd      s1, PT_EPC(sp)
    mv      a0, sp             /* pt_regs * 전달 */
    call    do_trap_ecall_u    /* C 핸들러 */
    j       ret_from_exception
SYM_CODE_END(handle_exception)

/* RISC-V 인라인 어셈블리 예시 (커널) */
static inline void local_irq_disable(void)
{
    asm volatile ("csrc sstatus, %0" :: "r"(SR_SIE) : "memory");
}

static inline void local_flush_tlb_all(void)
{
    asm volatile ("sfence.vma" ::: "memory");
}

RVC 압축 명령어

RISC-V C(Compressed) 확장은 자주 사용하는 명령어의 16비트 인코딩을 제공하여 코드 밀도를 향상시킵니다. 커널에서는 CONFIG_RISCV_ISA_C로 활성화합니다.

/* RVC 압축 명령어 예시 — 함수 프롤로그/에필로그 */
func:
    c.addi  sp, -16     /* 스택 프레임 할당 (16비트) */
    c.sd    ra, 8(sp)    /* 복귀 주소 저장 (16비트) */
    c.sd    s0, 0(sp)    /* callee-saved 레지스터 저장 */
    ...
    c.ld    ra, 8(sp)    /* 복귀 주소 복원 */
    c.ld    s0, 0(sp)
    c.addi  sp, 16
    c.jr    ra           /* jalr x0, 0(ra) */

/* 32비트 등가 코드보다 코드 크기 ~25-30% 절감 */
/* 제한: x8-x15(s0-s7, a0-a7 중 일부)만 사용 가능한 명령어 존재 */

커널 진입/탈출 코드

커널의 가장 중요한 어셈블리 코드는 유저 공간↔커널 공간 전환을 담당하는 진입/탈출 코드입니다. 시스템 콜, 인터럽트, 예외 처리 시 정확한 컨텍스트 저장/복원이 필수입니다.

x86_64 시스템 콜 진입 (상세)

/* arch/x86/entry/entry_64.S - 시스템 콜 진입 흐름 */
SYM_CODE_START(entry_SYSCALL_64)
    /* 1. GS base 교체: 유저 → 커널 per-CPU */
    swapgs

    /* 2. 유저 RSP를 per-CPU에 임시 저장 */
    movq    %rsp, PER_CPU_VAR(cpu_tss_rw + TSS_sp2)

    /* 3. 커널 스택으로 전환 */
    movq    PER_CPU_VAR(cpu_current_top_of_stack), %rsp

    /* 4. 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에 저장) */

    /* 5. 에러 코드 + 범용 레지스터 저장 */
    pushq   $-1                     /* 에러 코드 자리 (syscall은 없음) */
    PUSH_AND_CLEAR_REGS rax=$__NR_syscall_max

    /* 6. C 함수 호출: do_syscall_64(regs, nr) */
    movq    %rsp, %rdi              /* 첫 번째 인자: pt_regs 포인터 */
    movslq  %eax, %rsi              /* 두 번째 인자: syscall 번호 */
    call    do_syscall_64
    /* ... 복귀 경로 ... */
SYM_CODE_END(entry_SYSCALL_64)

컨텍스트 저장/복원 (pt_regs)

/* arch/x86/include/asm/ptrace.h */
struct pt_regs {
    unsigned long r15, r14, r13, r12;
    unsigned long bp;    /* rbp */
    unsigned long bx;    /* rbx */
    unsigned long r11, r10, r9, r8;
    unsigned long ax;    /* rax - syscall 반환값 */
    unsigned long cx, dx, si, di;
    unsigned long orig_ax;  /* syscall 번호 원본 */
    unsigned long ip;    /* RIP */
    unsigned long cs;
    unsigned long flags; /* RFLAGS */
    unsigned long sp;    /* RSP */
    unsigned long ss;
};

인터럽트 진입 경로

인터럽트는 시스템 콜과 달리 어디서든 발생할 수 있으므로 더 신중한 컨텍스트 저장이 필요합니다. x86_64에서 CPU는 자동으로 SS, RSP, RFLAGS, CS, RIP를 IST(Interrupt Stack Table) 또는 커널 스택에 푸시합니다.

/* 인터럽트 진입 매크로 (개념적) */
.macro idtentry_irq vector cfunc
SYM_CODE_START(asm_\cfunc)
    /* CPU가 자동 저장: SS, RSP, RFLAGS, CS, RIP */
    pushq   $~(\vector)          /* 에러 코드 위치에 벡터 저장 */
    call    error_entry           /* 범용 레지스터 저장, swapgs */
    movq    %rsp, %rdi           /* pt_regs 포인터 */
    movl    \vector, %esi        /* IRQ 번호 */
    call    \cfunc               /* C 핸들러 호출 */
    jmp     error_return         /* 레지스터 복원, iretq */
SYM_CODE_END(asm_\cfunc)
.endm

예외/NMI 처리 어셈블리

커널의 예외·인터럽트·NMI 처리는 어셈블리 진입점에서 시작됩니다. CPU가 자동으로 저장하는 레지스터, 에러 코드 유무, 스택 전환 메커니즘(IST)을 정확히 이해해야 커널 크래시를 디버깅할 수 있습니다.

Page Fault 핸들러 어셈블리 경로

Page fault는 커널에서 가장 빈번한 예외입니다. 유저 공간 메모리 접근, 지연 매핑(lazy allocation), Copy-on-Write 모두 #PF를 경유합니다.

/* arch/x86/entry/entry_64.S — Page Fault 진입 */
SYM_CODE_START(asm_exc_page_fault)
    endbr64
    /* CPU가 자동 push: SS, RSP, RFLAGS, CS, RIP, error_code */

    /* 1. KPTI: 유저→커널 페이지 테이블 전환 */
    ALTERNATIVE "jmp .Lpf_no_kpti", "", X86_FEATURE_PTI
    pushq   %rax
    movq    %cr3, %rax
    andq    $(~PTI_USER_PGTABLE_AND_PCID_MASK), %rax
    movq    %rax, %cr3          /* 커널 페이지 테이블로 전환 */
    popq    %rax
.Lpf_no_kpti:

    /* 2. 에러 코드를 orig_rax 위치에 저장 */
    pushq   %rax                /* pt_regs.orig_ax = error_code */

    /* 3. 전체 레지스터 저장 (pt_regs 구성) */
    PUSH_AND_CLEAR_REGS
    movq    %rsp, %rdi          /* 첫 번째 인자: pt_regs * */
    movq    ORIG_RAX(%rsp), %rsi /* 두 번째 인자: error_code */

    /* 4. C 핸들러 호출 */
    call    exc_page_fault      /* mm/fault.c */

    /* 5. 복귀 */
    jmp     error_return
SYM_CODE_END(asm_exc_page_fault)

/* mm/fault.c — C 레벨 핸들러 (간략) */
void exc_page_fault(struct pt_regs *regs, unsigned long error_code)
{
    unsigned long address = read_cr2();  /* fault 주소 */

    if (user_mode(regs))
        handle_user_fault(regs, error_code, address);
    else
        handle_kernel_fault(regs, error_code, address);
        /* → fixup_exception() → __ex_table 검색 → 복구 또는 oops */
}

General Protection Fault (#GP) 경로

#GP는 세그먼트 위반, 비정규 주소 접근, 특권 명령어 실행 등 다양한 원인으로 발생합니다. 커널에서 #GP가 발생하면 대부분 oops로 이어집니다.

/* #GP 에러 코드 해석 */
/* error_code = 0         : 일반적 보호 위반 */
/* error_code = selector  : 세그먼트 관련 위반 */
/*   bit 0 (EXT): 외부 이벤트로 인한 예외 */
/*   bit 1 (IDT): IDT의 디스크립터 참조 */
/*   bit 2 (TI) : 0=GDT, 1=LDT */
/*   bit 15:3   : 세그먼트 셀렉터 인덱스 */

/* 커널 #GP 발생 시 oops 출력 예시 */
/* general protection fault, probably for non-canonical address 0xdead... */
/* CPU: 3 PID: 1234 Comm: myapp Not tainted */
/* RIP: 0010:some_function+0x42/0x100 */
/* RSP: 0018:ffffc90000003e00 EFLAGS: 00010246 */
/* Code: 48 8b 07 48 85 c0 74 0a ... */

NMI 핸들러 어셈블리

NMI는 마스크 불가능하므로 커널의 어떤 지점에서든 발생할 수 있습니다. 심지어 다른 예외 처리 중이나 swapgs 도중에도 발생 가능하여, 특별한 주의가 필요합니다.

/* arch/x86/entry/entry_64.S — NMI 핸들러 (핵심 흐름) */
SYM_CODE_START(asm_exc_nmi)
    /* NMI는 IST1 스택으로 진입 */

    /* 1. 중첩 NMI 감지 */
    /*    IST 스택 top에 마커를 두고 재진입 여부 판단 */
    testb   $3, CS-RIP+8(%rsp)    /* 유저 모드에서 왔나? */
    jnz     .Lnmi_from_user

.Lnmi_from_kernel:
    /* 2. 커널 모드 NMI: 커널 스택이 유효한지 확인 */
    /*    이전 NMI 처리 중이면 repeat_nmi로 분기 */
    movq    %rsp, %rdx
    cmpq    nmi_stack_top(%rip), %rdx
    ja      .Lnmi_nested

    /* 3. 스택 프레임을 커널 스택으로 복사 */
    /*    IST 스택은 NMI 고유이므로 장기 사용 불가 */
    pushq   %rdx
    PUSH_AND_CLEAR_REGS

    /* 4. C 핸들러 호출 */
    movq    %rsp, %rdi
    call    exc_nmi                /* perf, watchdog, kgdb 등 */

    /* 5. 복귀: IRET으로만 (sysret 사용 불가) */
    POP_REGS
    addq    $8, %rsp              /* error code skip */
    iretq                          /* IRET 실행 → NMI 블록 해제 */
SYM_CODE_END(asm_exc_nmi)

/* NMI 용도 */
/* - perf: PMU 카운터 오버플로 → 샘플링 */
/* - watchdog: hard lockup 감지 (hrtimer → perf NMI) */
/* - kgdb: 원격 디버거 breakpoint */
/* - MCE: 일부 Machine Check도 NMI로 전달 */

Machine Check Exception (#MC) 처리

MCE는 하드웨어 오류(ECC 메모리, CPU 내부, 버스 등)를 보고합니다. IST3 스택을 사용하며, 복구 가능/불가능 여부에 따라 처리가 달라집니다.

/* MCE 처리 흐름 */
/* 1. CPU가 #MC 예외 발생 → IST3 스택으로 전환 */
/* 2. asm_exc_machine_check → exc_machine_check() */
/* 3. MSR에서 MCE 뱅크 읽기 (IA32_MCi_STATUS/ADDR/MISC) */

/* MCE 뱅크 읽기 어셈블리 */
static inline u64 mce_rdmsrl(u32 msr)
{
    u64 val;
    asm volatile (
        "1: rdmsr\n"
        "2:\n"
        ".pushsection __ex_table,\"a\"\n"
        "  .balign 4\n"
        "  .long 1b - ., 2b - .\n"       /* 실패 시 건너뜀 */
        ".popsection\n"
        : "=A" (val)
        : "c" (msr)
    );
    return val;
}

/* IA32_MCi_STATUS 비트 필드 */
/* bit 63 (VAL)  : 유효한 에러 */
/* bit 62 (OVER) : 오버플로 (이전 에러 손실) */
/* bit 61 (UC)   : 복구 불가능 (Uncorrected) */
/* bit 60 (EN)   : 에러 보고 활성화 */
/* bit 59 (MISCV): MISC 레지스터 유효 */
/* bit 58 (ADDRV): ADDR 레지스터 유효 */
/* bit 57 (PCC)  : 프로세서 컨텍스트 손상 → 패닉 */
/* bit 56 (S)    : Signaling (SRAR/SRAO 구분) */
/* bit 55 (AR)   : Action Required (즉시 조치 필요) */

어셈블리 메모리 배리어

현대 CPU는 성능을 위해 메모리 연산 순서를 재배치합니다. 멀티프로세서 환경에서 올바른 동작을 보장하려면 메모리 배리어가 필수입니다.

x86 메모리 배리어

x86은 비교적 강한 메모리 순서를 보장하는 TSO (Total Store Ordering) 모델을 사용합니다. 그러나 일부 상황에서는 명시적 배리어가 필요합니다.

/* x86 하드웨어 배리어 명령어 */
mfence                          /* 전체 배리어: 모든 load/store 완료 보장 */
lfence                          /* 로드 배리어: 이전 load 완료 후 다음 실행 */
sfence                          /* 스토어 배리어: 이전 store 완료 보장 */

/* lock 접두사: 원자적 RMW + 전체 배리어 효과 */
lock incl (%rdi)                /* 원자적 증가 + 암묵적 mfence */
lock cmpxchgl %eax, (%rdi)      /* 원자적 CAS */
lock xaddl %eax, (%rdi)         /* 원자적 교환 후 덧셈 */

/* 커널 배리어 매크로 (arch/x86/include/asm/barrier.h) */
#define mb()     asm volatile("mfence" ::: "memory")
#define rmb()    asm volatile("lfence" ::: "memory")
#define wmb()    asm volatile("sfence" ::: "memory")

/* SMP 배리어: UP에서는 컴파일러 배리어만 */
#define smp_mb()   asm volatile("lock; addl $0,-4(%%rsp)" ::: "memory", "cc")
#define smp_rmb()  barrier()  /* x86 TSO: load는 순서 보장 */
#define smp_wmb()  barrier()  /* x86 TSO: store는 순서 보장 */

/* 컴파일러 배리어 (하드웨어 배리어 아님!) */
#define barrier() asm volatile("" ::: "memory")

ARM64 메모리 배리어

ARM64는 x86보다 약한 메모리 순서 모델을 사용하므로 배리어가 더 중요합니다.

/* ARM64 배리어 명령어 */
dmb     sy                      /* Data Memory Barrier (전체) */
dmb     ish                     /* Inner Shareable 도메인 */
dmb     ishld                   /* Inner Shareable, Load만 */
dmb     ishst                   /* Inner Shareable, Store만 */

dsb     sy                      /* Data Synchronization Barrier */
dsb     ish                     /* 모든 이전 메모리 접근 완료 보장 */

isb                             /* Instruction Synchronization Barrier */
                                /* 파이프라인 플러시, 시스템 레지스터 변경 후 필요 */

/* ARM64 커널 배리어 (arch/arm64/include/asm/barrier.h) */
#define mb()     asm volatile("dmb sy" ::: "memory")
#define rmb()    asm volatile("dmb ld" ::: "memory")
#define wmb()    asm volatile("dmb st" ::: "memory")

#define smp_mb()   asm volatile("dmb ish" ::: "memory")
#define smp_rmb()  asm volatile("dmb ishld" ::: "memory")
#define smp_wmb()  asm volatile("dmb ishst" ::: "memory")

/* ARM64 Acquire/Release 의미론 (LDAR/STLR) */
/* smp_load_acquire → LDAR: 이후 load/store가 앞으로 재배치 안 됨 */
/* smp_store_release → STLR: 이전 load/store가 뒤로 재배치 안 됨 */

문자열/메모리 연산 어셈블리

x86의 REP 접두사 문자열 연산과 ERMS/FSRM 최적화는 커널의 memcpy, memset, copy_to_user 등 핵심 메모리 연산의 기반입니다.

REP MOVSB/STOSB/CMPSB

REP 접두사는 RCX 카운터가 0이 될 때까지 문자열 명령어를 반복 실행합니다. 방향 플래그(DF)가 주소 증감 방향을 결정합니다.

/* 기본 메모리 복사: RDI=dest, RSI=src, RCX=count */
    cld               /* DF=0: 주소 증가 방향 */
    rep movsb        /* while(RCX--) *RDI++ = *RSI++ */

/* 메모리 채우기: RDI=dest, AL=value, RCX=count */
    cld
    rep stosb        /* while(RCX--) *RDI++ = AL */

/* 8바이트 단위 복사 (더 효율적) */
    mov   %rcx, %rax
    shr   $3, %rcx     /* count / 8 */
    rep movsq          /* 8바이트씩 복사 */
    mov   %rax, %rcx
    and   $7, %rcx     /* 나머지 바이트 */
    rep movsb          /* 1바이트씩 나머지 복사 */

ERMS/FSRM 최적화

Enhanced REP MOVSB/STOSB(ERMS)와 Fast Short REP MOV(FSRM)는 마이크로아키텍처 수준에서 REP MOV 성능을 크게 향상시킵니다.

/* arch/x86/lib/memcpy_64.S — ALTERNATIVE 기반 memcpy 선택 */
SYM_FUNC_START(__memcpy)
    ALTERNATIVE_2 "jmp memcpy_orig",       \
                   "jmp memcpy_erms", X86_FEATURE_ERMS, \
                   "jmp memcpy_fsrm", X86_FEATURE_FSRM

/* ERMS 경로: 단순하지만 대량 데이터에 최적 */
SYM_FUNC_START_LOCAL(memcpy_erms)
    movq %rdi, %rax   /* 반환값 = dest */
    movq %rdx, %rcx   /* count */
    rep movsb         /* ERMS 최적화 경로 */
    RET
SYM_FUNC_END(memcpy_erms)

커널 memcpy/memset 어셈블리

커널의 memcpy와 memset은 CPU 피처에 따라 런타임에 최적 구현이 선택됩니다.

copy_to_user/copy_from_user

유저↔커널 메모리 복사는 페이지 폴트 발생 가능성과 SMAP 보호를 고려해야 합니다. 예외 테이블과 STAC/CLAC로 안전하게 처리합니다.

/* arch/x86/lib/copy_user_64.S */
SYM_FUNC_START(copy_user_generic_unrolled)
    stac                    /* SMAP 해제: 유저 메모리 접근 허용 */
    cmpl $8, %edx
    jb   .Lbyte_copy

    /* 정렬 맞춤 */
    movl %edi, %ecx
    andl $7, %ecx
    jz   .Lqword_copy
    subl $8, %ecx
    negl %ecx
    subl %ecx, %edx
0:  movb (%rsi), %al       /* ← fault 가능 지점 */
1:  movb %al, (%rdi)
    ...

    clac                    /* SMAP 복원 */
    RET

    /* 예외 테이블 엔트리 */
    _ASM_EXTABLE_UA(0b, .Lcopy_user_handle_tail)
    _ASM_EXTABLE_UA(1b, .Lcopy_user_handle_tail)

.Lcopy_user_handle_tail:
    clac                    /* 반드시 CLAC */
    movl %edx, %ecx         /* 남은 바이트 수 */
    xorl %eax, %eax
    rep stosb              /* 나머지를 0으로 채움 */
    movl %edx, %eax         /* 미복사 바이트 수 반환 */
    RET
SYM_FUNC_END(copy_user_generic_unrolled)

비트 조작 명령어

커널은 비트맵, 스케줄러 우선순위, 자원 할당 등에서 비트 스캔·조작 명령어를 광범위하게 사용합니다. x86의 전통적인 BSF/BSR부터 BMI1/BMI2 확장까지 다룹니다.

BSF/BSR/BT/BTC/BTR/BTS

/* BSF/BSR 커널 사용 패턴 */
static inline unsigned long __ffs(unsigned long word)
{
    asm("rep; bsf %1,%0"    /* rep bsf = tzcnt (BMI 지원 시) */
        : "=r"(word)
        : "rm"(word));
    return word;
}

static inline unsigned long __fls(unsigned long word)
{
    asm("bsr %1,%0"
        : "=r"(word)
        : "rm"(word));
    return word;
}

/* __ffs vs ffs 차이:
 * __ffs(x): 0-indexed, x=0이면 미정의 (호출자가 보장)
 * ffs(x):   1-indexed, x=0이면 0 반환 (POSIX)
 * ffz(x):   ~x에서 첫 번째 0비트 위치 */

BMI1/BMI2 명령어

커널 비트 연산 함수

include/asm-generic/bitops/와 arch/x86/include/asm/bitops.h에 정의된 커널 비트 연산 함수들의 어셈블리 구현입니다.

/* arch/x86/include/asm/bitops.h */
static __always_inline void set_bit(long nr, volatile unsigned long *addr)
{
    asm volatile (
        LOCK_PREFIX "btsq %1,%0"
        : "+m"(*(volatile long *)
          (((unsigned long)addr) + (nr >> 6) * 8))
        : "Ir"(nr & 63)
        : "memory"
    );
}

static __always_inline bool test_and_set_bit(long nr, volatile unsigned long *addr)
{
    GEN_BINARY_RMWcc(LOCK_PREFIX "btsq",
                     *addr, "Ir", nr, "%0", c);
    /* CF(carry flag)가 이전 비트 값 → setc로 반환 */
}

특권 명령어

Ring 0(커널 모드)에서만 실행할 수 있는 특권 명령어들은 커널의 하드웨어 제어, 메모리 관리, 가상화 지원의 핵심입니다.

Ring 0 전용 명령어

가상화 명령어

Intel VT-x(VMX)는 하드웨어 가상화를 위한 명령어 세트로, KVM의 핵심 기반입니다.

/* arch/x86/kvm/vmx/vmx.c — KVM VMX 진입 */
static void vmx_vcpu_run(struct kvm_vcpu *vcpu)
{
    /* 게스트 레지스터 복원 */
    asm volatile (
        /* 호스트 레지스터 저장 */
        "push %%" _ASM_BP "\n\t"
        "push %%" _ASM_DX "\n\t"
        ...
        /* 게스트 레지스터 로드 */
        "mov %c[rax](%0), %%" _ASM_AX "\n\t"
        "mov %c[rcx](%0), %%" _ASM_CX "\n\t"
        ...
        /* VM Entry */
        "jne 1f\n\t"
        "vmlaunch\n\t"          /* 최초 진입 */
        "jmp 2f\n\t"
        "1: vmresume\n\t"       /* 재진입 */
        "2: "
        /* VM Exit: 여기로 복귀 */
        ...
    );
}

SGX 명령어

Intel SGX(Software Guard Extensions)는 하드웨어 격리된 Enclave를 제공합니다. 최신 Intel CPU에서는 SGX가 단계적으로 폐지(deprecated)되고 있습니다.

SMAP/SMEP: STAC/CLAC 상세

SMAP(Supervisor Mode Access Prevention)과 SMEP(Supervisor Mode Execution Prevention)는 커널이 유저 메모리를 의도치 않게 접근/실행하는 것을 방지합니다.

/* SMAP 제어 */
static inline void stac(void)
{
    /* STAC: Set AC Flag → SMAP 일시 해제 */
    /* 커널이 유저 메모리 접근 허용 */
    alternative("", __stringify(stac), X86_FEATURE_SMAP);
}

static inline void clac(void)
{
    /* CLAC: Clear AC Flag → SMAP 복원 */
    /* 유저 메모리 접근 시 #PF 발생 */
    alternative("", __stringify(clac), X86_FEATURE_SMAP);
}

/* 사용 패턴 */
unsigned long copy_from_user(void *to, const void __user *from, unsigned long n)
{
    if (access_ok(from, n)) {
        stac();          /* 유저 접근 허용 */
        n = raw_copy_from_user(to, from, n);
        clac();          /* 유저 접근 차단 복원 */
    }
    return n;
}

/* CR4 비트:
 * CR4.SMAP (비트 21): Supervisor Mode Access Prevention
 *   - 1: Ring 0에서 AC=0일 때 유저 페이지 접근 → #PF
 * CR4.SMEP (비트 20): Supervisor Mode Execution Prevention
 *   - 1: Ring 0에서 유저 페이지 코드 실행 → #PF
 *   - SMEP는 AC 플래그와 무관 (항상 차단)
 */

보안 완화 어셈블리

Spectre, Meltdown 등 투기적 실행 취약점이 발견된 이후, 커널은 어셈블리 수준에서 다양한 완화 기법을 적용합니다. ALTERNATIVE 매크로, Static Key / Jump Label, Retpoline, IBRS/IBPB 등은 모두 어셈블리와 직결됩니다.

Retpoline 상세 동작

Retpoline은 간접 호출(call *%rax)을 call+ret 시퀀스로 변환하여 CPU의 간접 분기 예측기(BTB)가 투기적으로 공격자 제어 주소를 실행하는 것을 방지합니다.

/* arch/x86/lib/retpoline.S — __x86_indirect_thunk_rax */
SYM_FUNC_START(__x86_indirect_thunk_rax)
    /* 1. 반환 주소를 스택에 push하면서 .Lspec_trap으로 점프 */
    call    .Ltarget               /* RSB에 .Ltarget 주소 기록 */

.Lspec_trap:
    /* 2. 투기적 실행이 여기로 올 경우 무한 루프에 갇힘 */
    lfence                         /* 투기 실행 직렬화 (Intel) */
    jmp     .Lspec_trap            /* 실제로는 도달 불가 */

.Ltarget:
    /* 3. 스택 top의 반환 주소를 목표 주소로 교체 */
    movq    %rax, (%rsp)           /* call이 push한 .Lspec_trap을 덮어씀 */
    /* 4. ret로 간접 점프 → RSB 예측은 .Lspec_trap, 실제는 %rax */
    RET                            /* ret; int3 (SLS 완화 포함) */
SYM_FUNC_END(__x86_indirect_thunk_rax)

/* 컴파일러가 생성하는 호출 코드 (retpoline 모드) */
/* call *%rax  →  call __x86_indirect_thunk_rax */

ALTERNATIVE 매크로 구조

커널은 부팅 시점에 apply_alternatives()를 호출하여 .altinstructions 섹션의 메타데이터를 순회하면서, CPU 피처 비트에 따라 코드를 런타임 패칭합니다.

/* arch/x86/include/asm/alternative.h — ALTERNATIVE 매크로 */
#define ALTERNATIVE(oldinstr, newinstr, feature)          \
    "661:\n\t" oldinstr "\n662:\n"                        \
    ".pushsection .altinstructions,\"a\"\n"               \
    "  .long 661b - .\n"     /* 원본 명령어 오프셋 */   \
    "  .long 663f - .\n"     /* 대체 명령어 오프셋 */   \
    "  .word " __stringify(feature) "\n" /* CPU 피처 */ \
    "  .byte 662b-661b\n"    /* 원본 길이 */           \
    "  .byte 664f-663f\n"    /* 대체 길이 */           \
    ".popsection\n"                                       \
    ".pushsection .altinstr_replacement,\"ax\"\n"         \
    "663:\n\t" newinstr "\n664:\n"                        \
    ".popsection\n"

/* 사용 예: SMAP이 지원되면 nop → clac으로 패칭 */
static inline void clac(void)
{
    alternative("nop; nop; nop",                /* 기본: 3바이트 nop */
                "clac",                         /* SMAP 지원 시 */
                X86_FEATURE_SMAP);
}

/* 다중 대안 예: 3가지 구현 중 선택 */
ALTERNATIVE_2(
    "call memcpy_orig",                     /* 기본 구현 */
    "call memcpy_erms", X86_FEATURE_ERMS,   /* REP MOVSB 최적화 */
    "call memcpy_fsrm", X86_FEATURE_FSRM    /* Fast Short REP MOV */
)

Static Key 어셈블리 메커니즘

앞의 Static Key와 asm goto, 컴파일부터 런타임 패칭까지의 파이프라인, x86에서 안전하게 패칭되는 이유 절이 전체 메커니즘을 설명했다면, 아래 코드는 그 내용을 x86 바이트 수준에서 다시 압축한 요약입니다.

/* include/linux/jump_label.h + arch/x86/kernel/jump_label.c */

/* C 코드 */
DEFINE_STATIC_KEY_FALSE(my_feature);

void hot_path(void)
{
    /* 비활성 상태: 5바이트 NOP으로 컴파일됨 */
    if (static_branch_unlikely(&my_feature)) {
        do_extra_work();
    }
    /* 핫 패스는 분기 예측 비용 0 */
}

/* 생성되는 어셈블리 (비활성) */
    .byte 0x0f,0x1f,0x44,0x00,0x00   /* 5바이트 NOP (nopl 0(%rax,%rax,1)) */
    /* __jump_table 섹션에 엔트리 기록 */

/* static_branch_enable(&my_feature) 호출 후 패칭 */
    .byte 0xe9,xx,xx,xx,xx           /* 5바이트 JMP rel32 */

/* text_poke_bp() 3단계 안전 패칭 */
/*  1) int3 (0xCC) 1바이트 삽입 → 다른 CPU가 실행하면 breakpoint */
/*  2) 나머지 4바이트 패칭 (int3 뒤이므로 안전) */
/*  3) int3 → jmp opcode(0xE9)로 교체 + sync_core() */

CET: endbr64와 간접 분기 추적 (IBT)

Intel CET (Control-flow Enforcement Technology)의 IBT 모드에서는 모든 간접 분기 타겟에 endbr64 명령어가 있어야 합니다. 없으면 #CP (Control Protection) 예외가 발생합니다.

/* 커널 6.2+: CONFIG_X86_KERNEL_IBT=y */

/* 모든 함수 진입점에 endbr64 자동 삽입 */
SYM_FUNC_START(my_function)
    endbr64                        /* f3 0f 1e fa — 간접 분기 타겟 표시 */
    pushq   %rbp
    ...

/* 인터럽트/예외 핸들러 진입점도 동일 */
SYM_CODE_START(asm_exc_page_fault)
    endbr64
    ...

/* IBT가 미지원이면 ALTERNATIVE로 nop4로 패칭 */
/* endbr64 (4B) → nopl 0(%rax,%rax,1) (4B) */

/* Shadow Stack (CET-SS): CALL은 shadow stack에도 리턴 주소 push */
/* RET 시 일반 스택과 shadow stack 비교 → 불일치 시 #CP 예외 */
/* 커널은 CONFIG_X86_USER_SHADOW_STACK으로 유저 공간 CET-SS 지원 */

Spectre/Meltdown 완화 심화

2018년 이후 발견된 투기적 실행 취약점들은 커널 어셈블리 수준에서 다양한 완화 기법을 필요로 합니다. 각 취약점별로 MSR 제어, 코드 패칭, 페이지 테이블 분리 등 구체적인 어셈블리 메커니즘을 이해해야 합니다.

IBRS/IBPB/STIBP 상세

간접 분기 예측 공격(Spectre v2)을 완화하기 위한 핵심 MSR 기반 메커니즘입니다.

/* arch/x86/include/asm/nospec-branch.h */
static inline void __wrmsr_ibrs(u64 val)
{
    asm volatile (
        "wrmsr"
        : : "c"(MSR_IA32_SPEC_CTRL),
            "a"((u32)val),
            "d"((u32)(val >> 32))
        : "memory"
    );
}

/* 커널 진입 시 IBRS 설정 */
static inline void indirect_branch_prediction_barrier(void)
{
    asm volatile (
        ALTERNATIVE("" , "wrmsr", X86_FEATURE_USE_IBPB)
        : : "a"(1), "c"(MSR_IA32_PRED_CMD), "d"(0)
        : "memory"
    );
}

KPTI 어셈블리

KPTI(Kernel Page Table Isolation)는 Meltdown 취약점에 대한 완화로, 유저 모드와 커널 모드에서 서로 다른 페이지 테이블을 사용합니다.

/* arch/x86/entry/calling.h — KPTI CR3 스위치 매크로 */
.macro SWITCH_TO_KERNEL_CR3 scratch_reg:req
    mov     %cr3, \scratch_reg
    andq    $(~PTI_USER_PGTABLE_AND_PCID_MASK), \scratch_reg
    mov     \scratch_reg, %cr3
.endm

.macro SWITCH_TO_USER_CR3_NOSTACK scratch_reg:req scratch_reg2:req
    mov     %cr3, \scratch_reg
    movq    PER_CPU_VAR(cpu_tlbstate + TLB_STATE_user_pcid_flush_mask), \scratch_reg2
    orq     \scratch_reg2, \scratch_reg
    mov     \scratch_reg, %cr3
.endm

/* PTI_USER_PGTABLE_AND_PCID_MASK = PAGE_SIZE (0x1000) */
/* 커널 PGD + 0x1000 = 유저 PGD (연속 할당) */

MDS/TAA/MMIO 완화

Microarchitectural Data Sampling(MDS) 계열 취약점은 CPU 내부 버퍼(Store Buffer, Fill Buffer, Load Port)의 잔류 데이터를 투기적 실행으로 읽어내는 공격입니다.

/* arch/x86/include/asm/nospec-branch.h */
/* VERW는 MD_CLEAR가 지원되는 CPU에서 내부 버퍼를 클리어 */
.macro CLEAR_CPU_BUFFERS
    ALTERNATIVE "", "verw _requests(%rip)", X86_FEATURE_CLEAR_CPU_BUF
.endm

/* _requests는 유효한 DS 세그먼트 셀렉터를 가리킴 */
/* VERW 명령어: 쓰기 가능 여부 확인 + 부작용으로 버퍼 클리어 */

/* 커널→유저 복귀 시 버퍼 클리어 */
SYM_FUNC_START(entry_SYSCALL_64)
    ...
    CLEAR_CPU_BUFFERS      /* 유저 복귀 직전 */
    sysretq
SYM_FUNC_END(entry_SYSCALL_64)

L1TF/L1D Flush

L1 Terminal Fault(L1TF)는 PTE의 Present 비트가 0일 때 PFN 필드가 L1D 캐시 태그 검사에 사용되는 취약점입니다. VM exit 시 L1D 캐시를 플러시하여 게스트 간 데이터 누출을 방지합니다.

/* L1D 플러시 — IA32_FLUSH_CMD MSR (0x10B) */
static inline void l1d_flush_hw(void)
{
    asm volatile (
        "wrmsr"
        : : "c"(0x10B),    /* IA32_FLUSH_CMD */
            "a"(1),        /* L1D_FLUSH bit */
            "d"(0)
        : "memory"
    );
}

/* PTE 역전 (L1TF 완화) — Present=0인 PTE의 PFN을 무효화 */
/* arch/x86/include/asm/pgtable.h */
static inline pte_t pte_set_flags(pte_t pte, pteval_t set)
{
    /* Present=0이면 물리 주소 비트를 반전 → L1D 히트 방지 */
    return __pte(native_pte_val(pte) | set);
}

SSBD/PSFD

Speculative Store Bypass(SSB, Spectre v4)는 저장(store) 후 같은 주소의 로드(load)가 투기적으로 이전 값을 읽는 취약점입니다.

/* SSBD — IA32_SPEC_CTRL.SSBD (비트 2) */
static inline void ssbd_set(void)
{
    u64 val = spec_ctrl_current() | SPEC_CTRL_SSBD;
    wrmsrl(MSR_IA32_SPEC_CTRL, val);
}

/* 프로세스별 SSBD 제어 — prctl() */
/* prctl(PR_SET_SPECULATION_CTRL, PR_SPEC_STORE_BYPASS, PR_SPEC_DISABLE) */
/* 스레드 구조체에 TIF_SSBD 플래그 설정 → 컨텍스트 전환 시 MSR 업데이트 */

/* PSFD — Predictive Store Forwarding Disable */
/* AMD Zen 3+에서 지원, 예측적 스토어 포워딩 비활성화 */
/* IA32_SPEC_CTRL 비트 7 (AMD specific) */

성능 카운터 어셈블리

x86과 ARM64의 하드웨어 성능 카운터(PMU)를 어셈블리 수준에서 설정하고 읽는 방법을 다룹니다. 커널의 perf 서브시스템이 사용하는 저수준 메커니즘을 이해합니다.

RDTSC/RDTSCP/RDPMC

타임스탬프 카운터와 성능 카운터를 직접 읽는 명령어입니다.

/* 정확한 TSC 읽기 패턴 */
static inline u64 rdtsc_ordered(void)
{
    /* RDTSCP: 이전 명령어 완료 후 TSC 읽기 보장 */
    u32 lo, hi;
    asm volatile (
        "rdtscp"
        : "=a"(lo), "=d"(hi)
        : : "rcx"     /* ECX = IA32_TSC_AUX 클러버 */
    );
    return ((u64)hi << 32) | lo;
}

/* RDTSC + LFENCE 패턴 (RDTSCP 미지원 CPU용) */
static inline u64 rdtsc_lfence(void)
{
    u32 lo, hi;
    asm volatile (
        "lfence\n\t"
        "rdtsc"
        : "=a"(lo), "=d"(hi)
        : : "memory"
    );
    return ((u64)hi << 32) | lo;
}

/* 커널에서 TSC 기반 시간 측정 */
/* ktime_get_ns() → clocksource_tsc → rdtsc_ordered() */

PMU 설정 어셈블리

Intel/AMD Performance Monitoring Unit의 MSR을 직접 설정하여 하드웨어 이벤트를 카운트합니다.

/* PMU 직접 설정 예제 */
static inline void pmu_start_counting(u32 event, u32 umask, int counter)
{
    u64 evtsel = event | (umask << 8) |
                (1ULL << 16) |   /* USR: 유저 모드 카운트 */
                (1ULL << 17) |   /* OS: 커널 모드 카운트 */
                (1ULL << 22);    /* EN: 카운터 활성화 */

    /* 카운터 초기화 */
    wrmsrl(MSR_IA32_PMC0 + counter, 0);
    /* 이벤트 선택 및 활성화 */
    wrmsrl(MSR_IA32_PERFEVTSEL0 + counter, evtsel);
}

/* 카운터 읽기 */
static inline u64 pmu_read_counter(int counter)
{
    u64 val;
    rdmsrl(MSR_IA32_PMC0 + counter, val);
    return val;
}

/* NMI 기반 샘플링: 오버플로 시 PMI 발생 */
/* perf_event → hw_perf_event_init() → pmu->enable() */

perf_event 연동

커널의 perf 서브시스템은 하드웨어 PMU 드라이버를 추상화하여 perf_event_open() 시스템 콜로 통합 인터페이스를 제공합니다.

/* perf_event 오픈 흐름 */
/* 사용자: perf_event_open(attr, pid, cpu, ...) */
/* ↓ */
/* 커널: perf_event_alloc() */
/*   → pmu->event_init(event)  // 이벤트 유효성 검사 */
/*   → pmu->add(event, ...)    // 카운터 할당 + MSR 설정 */
/*   → pmu->start(event)       // 카운팅 시작 */
/* ↓ */
/* NMI: perf_event_nmi_handler() */
/*   → pmu->handle_irq(...)    // 오버플로 처리 */
/*   → perf_event_overflow()   // 샘플 기록 */

/* arch/x86/events/core.c — x86 PMU 드라이버 등록 */
static struct pmu pmu = {
    .pmu_enable     = x86_pmu_enable,
    .pmu_disable    = x86_pmu_disable,
    .event_init     = x86_pmu_event_init,
    .add            = x86_pmu_add,
    .del            = x86_pmu_del,
    .start          = x86_pmu_start,
    .stop           = x86_pmu_stop,
    .read           = x86_pmu_read,
};

ARM64 PMU 레지스터

ARM64의 PMU(Performance Monitors Extension)는 시스템 레지스터를 통해 접근합니다.

/* ARM64 PMU 카운터 읽기 */
static inline u64 arm64_read_pmu_counter(int idx)
{
    u64 val;
    asm volatile ("mrs %0, pmevcntr0_el0" : "=r"(val));
    return val;
}

/* 사이클 카운터 읽기 */
static inline u64 arm64_read_ccnt(void)
{
    u64 val;
    asm volatile ("mrs %0, pmccntr_el0" : "=r"(val));
    return val;
}

/* PMU 초기화 */
static inline void arm64_pmu_enable(void)
{
    u64 val;
    asm volatile ("mrs %0, pmcr_el0" : "=r"(val));
    val |= 1;  /* E 비트: PMU 활성화 */
    asm volatile ("msr pmcr_el0, %0" : : "r"(val));
}

어셈블리 디버깅

커널 어셈블리 코드를 디버깅하는 것은 C 코드보다 어렵지만, 적절한 도구를 활용하면 효율적으로 문제를 찾을 수 있습니다.

objdump로 디스어셈블

# 커널 이미지 디스어셈블 (특정 함수)
objdump -d vmlinux | grep -A 30 '<do_syscall_64>:'

# 인라인 어셈블리 확인: C 소스와 어셈블리 혼합 출력
objdump -d -S -l vmlinux | less

# 특정 섹션만 디스어셈블
objdump -d -j .text vmlinux

# 모듈 디스어셈블
objdump -d my_module.ko

# 릴로케이션 정보 확인
objdump -r my_module.ko

GDB 디스어셈블

# QEMU + GDB로 커널 디버깅
qemu-system-x86_64 -kernel bzImage -s -S ...

# 다른 터미널에서
gdb vmlinux
(gdb) target remote :1234
(gdb) disassemble do_syscall_64       # 함수 디스어셈블
(gdb) x/20i $rip                      # 현재 위치부터 20개 명령어
(gdb) display/i $pc                   # 매 스텝마다 현재 명령어 표시
(gdb) stepi                           # 명령어 단위 스텝 (si)
(gdb) nexti                           # call 건너뛰기 (ni)
(gdb) info registers                  # 레지스터 확인
(gdb) p/x $rax                        # 특정 레지스터 값

# Intel 문법으로 전환
(gdb) set disassembly-flavor intel

ftrace function_graph로 흐름 추적

# function_graph tracer로 함수 호출 흐름 시각화
cd /sys/kernel/debug/tracing
echo function_graph > current_tracer
echo do_syscall_64 > set_graph_function   # 특정 함수 하위만
echo 1 > tracing_on
# ... 작업 수행 ...
cat trace

# 출력 예시:
#  0)               |  do_syscall_64() {
#  0)   0.150 us    |    syscall_enter_from_user_mode();
#  0)               |    __x64_sys_write() {
#  0)               |      ksys_write() {
#  0)   0.087 us    |        __fdget_pos();
#  0)               |        vfs_write() {
#  0)   ...

링커 스크립트 & 어셈블리 연동

커널 이미지(vmlinux)의 최종 레이아웃은 링커 스크립트(vmlinux.lds.S)가 결정합니다. 어셈블리 코드에서 선언한 섹션, 심볼, 정렬이 링커 스크립트와 정확히 맞물려야 부팅·예외 처리·모듈 로딩이 정상 동작합니다.

링커 스크립트 매크로

커널은 include/asm-generic/vmlinux.lds.h에 정의된 매크로를 통해 섹션 배치를 표준화합니다. 어셈블리 코드에서 사용하는 섹션 이름과 이 매크로가 정확히 대응해야 합니다.

SYM_* 매크로와 링커 심볼 가시성

커널 5.5+에서 도입된 SYM_* 매크로 계열은 어셈블리 심볼의 타입·바인딩·정렬을 표준화하고, 링커가 올바른 심볼 테이블을 생성하도록 합니다.

/* include/linux/linkage.h — SYM_* 매크로 정의 */

/* 함수 심볼: .type @function, ALIGN, GLOBAL */
SYM_FUNC_START(name)       /* 전역 함수, objtool 검증 대상 */
SYM_FUNC_START_LOCAL(name) /* 지역 함수 (.L 접두어 없이도 LOCAL) */
SYM_FUNC_START_WEAK(name)  /* 약한 바인딩 (아키텍처별 오버라이드) */
SYM_FUNC_END(name)         /* .size 계산, CFI 마무리 */

/* 코드 심볼: 함수가 아닌 코드 (진입점, 인터럽트 핸들러) */
SYM_CODE_START(name)       /* objtool이 스택 검증 건너뜀 */
SYM_CODE_END(name)

/* 데이터 심볼 */
SYM_DATA_START(name)       /* 전역 데이터 */
SYM_DATA(name, data...)    /* 단일 데이터 항목 */
SYM_DATA_END(name)

/* 실제 확장 예시: SYM_FUNC_START(memcpy) */
    .globl memcpy              /* 전역 심볼 */
    .p2align 4                 /* 16바이트 정렬 */
    .type memcpy, @function    /* ELF 함수 타입 */
memcpy:
    .cfi_startproc             /* DWARF 언와인드 시작 */

예외 테이블 섹션 (.pushsection __ex_table)

커널에서 유저 공간 메모리에 접근하는 어셈블리 코드는 page fault 시 복구 경로를 예외 테이블에 등록해야 합니다. .pushsection을 사용해 현재 섹션을 벗어나지 않고 테이블 엔트리를 삽입합니다.

/* arch/x86/lib/copy_user_64.S — 유저 메모리 복사 */
SYM_FUNC_START(copy_user_generic_unrolled)
    ...
1:  movq (%rsi), %r8           /* 유저 메모리 읽기 → page fault 가능 */
2:  movq 8(%rsi), %r9
    ...
3:  movq %r8, (%rdi)           /* 유저 메모리 쓰기 → page fault 가능 */
4:  movq %r9, 8(%rdi)
    ...

/* 예외 발생 시 복구 경로를 __ex_table에 등록 */
    .pushsection __ex_table, "a"
    .balign 4
    .long 1b - .               /* fault 명령어 오프셋 (상대) */
    .long .Lcopy_user_handle_tail - .  /* 복구 핸들러 오프셋 */
    .long 2b - .
    .long .Lcopy_user_handle_tail - .
    .long 3b - .
    .long .Lcopy_user_handle_tail - .
    .long 4b - .
    .long .Lcopy_user_handle_tail - .
    .popsection                /* 원래 섹션(.text)으로 복귀 */

/* 복구 핸들러: 남은 바이트 수를 반환 */
.Lcopy_user_handle_tail:
    movl %ecx, %edx            /* 복사 못한 바이트 수 */
    jmp copy_user_handle_tail
SYM_FUNC_END(copy_user_generic_unrolled)

__init / __initdata 섹션 어셈블리

부팅 시에만 필요한 코드와 데이터는 .init.text/.init.data 섹션에 배치하여 부팅 완료 후 free_initmem()으로 메모리를 해제합니다.

/* 어셈블리에서 __init 섹션 사용 */
    .section .init.text, "ax"
SYM_CODE_START(startup_64)
    /* 부팅 초기 코드: 페이지 테이블 설정, BSP 초기화 */
    leaq _text(%rip), %rdi
    ...
SYM_CODE_END(startup_64)

    .section .init.data, "aw"
    .balign 8
early_gdt:                     /* 부팅 시 임시 GDT — 나중에 해제됨 */
    .quad 0x0000000000000000   /* null descriptor */
    .quad 0x00af9a000000ffff   /* 64-bit code */
    .quad 0x00cf92000000ffff   /* 64-bit data */

/* C 코드에서의 __init 매크로 → 같은 섹션으로 매핑 */
/* #define __init  __section(".init.text") __cold __latent_entropy __noinitretpoline */
/* #define __initdata  __section(".init.data") */

참고자료

공식 매뉴얼 및 문서

• GNU Assembler (GAS) 매뉴얼 — info as 또는 GNU Binutils 문서에서 GAS 지시자, 매크로, 아키텍처별 옵션을 확인할 수 있습니다.
• GCC 인라인 어셈블리 — GCC 공식 문서의 "Extended Asm" 섹션에서 제약조건, clobber, goto 레이블 등 상세 문법을 다룹니다.
• Intel 64 and IA-32 Architectures Software Developer's Manual — Intel의 공식 x86 ISA 레퍼런스. 전체 명령어 세트, 시스템 프로그래밍 가이드를 포함합니다.
• ARM Architecture Reference Manual (ARMv8-A) — ARM 공식 AArch64 ISA 레퍼런스. A64 명령어 세트, 시스템 레지스터를 다룹니다.

추천 서적

• "Programming from the Ground Up" (Jonathan Bartlett) — x86 어셈블리 입문서. AT&T 문법 기반으로 Linux에서의 시스템 프로그래밍을 다룹니다. 무료 PDF 공개.
• "Professional Assembly Language" (Richard Blum) — GAS(GNU Assembler)를 이용한 x86 어셈블리 프로그래밍 가이드.
• "Linux Kernel Development" (Robert Love) — 커널 내부 구조와 함께 아키텍처 의존 코드를 설명합니다.

커널 소스 내 어셈블리 참고 위치

CPU 매뉴얼과 어셈블리 개발 실무

Intel SDM 읽는 법 — 명령어 레퍼런스 예시

Intel SDM Vol. 2의 각 명령어 항목은 다음과 같은 구조로 되어 있으며, 인라인 어셈블리 작성 시 반드시 확인해야 할 핵심 정보를 담고 있습니다:

/* Intel SDM Vol.2 명령어 항목 구조 예시: CMPXCHG */

/* Opcode    | Instruction          | Description */
/* 0F B0 /r  | CMPXCHG r/m8, r8     | Compare AL with r/m8 */
/* 0F B1 /r  | CMPXCHG r/m32, r32   | Compare EAX with r/m32 */
/* REX.W + 0F B1 /r | CMPXCHG r/m64, r64 | Compare RAX with r/m64 */

/* 핵심 확인 사항:
 * 1. Flags Affected: ZF (성공 시 set), CF/PF/AF/SF/OF
 * 2. #UD: LOCK prefix 없이 메모리 오퍼랜드에 사용 시 동작 정의
 * 3. LOCK prefix: 메모리 오퍼랜드에 LOCK 사용 가능 (atomic)
 * 4. 64-bit mode: REX.W prefix로 64비트 확장
 */

/* 커널에서의 실제 사용 — arch/x86/include/asm/cmpxchg.h */
static 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)
            : "r"(new), "m"(*(u64 *)ptr), "0"(old)
            : "memory");
        return prev;
    }
}

ARM ARM 읽는 법 — 시스템 레지스터

ARM 커널 코드에서는 시스템 레지스터 접근이 빈번합니다. ARM ARM의 시스템 레지스터 장은 각 레지스터의 비트 필드와 접근 조건을 정의합니다:

/* ARM ARM에서 SCTLR_EL1 레지스터 비트 필드 확인 후 커널 코드 이해 */
/* arch/arm64/include/asm/sysreg.h */
#define SCTLR_EL1_MMU_EN    (1 << 0)   /* M bit: MMU enable */
#define SCTLR_EL1_ALIGN     (1 << 1)   /* A bit: Alignment check */
#define SCTLR_EL1_DCACHE    (1 << 2)   /* C bit: Data cache enable */
#define SCTLR_EL1_WXN       (1 << 19)  /* WXN: Write implies XN */
#define SCTLR_EL1_ICACHE    (1 << 12)  /* I bit: Instruction cache */

/* ARM64 어셈블리에서 시스템 레지스터 접근 */
asm volatile("mrs %0, sctlr_el1" : "=r"(val));   /* 읽기 */
asm volatile("msr sctlr_el1, %0" :: "r"(val));    /* 쓰기 */
asm volatile("isb");  /* Instruction Synchronization Barrier 필수 */

RISC-V Privileged ISA — CSR 접근

/* RISC-V Privileged ISA에서 CSR 정의 확인 후 커널 코드 이해 */
/* arch/riscv/include/asm/csr.h */
#define CSR_SSTATUS     0x100   /* Supervisor Status */
#define CSR_SIE         0x104   /* Supervisor Interrupt Enable */
#define CSR_STVEC       0x105   /* Supervisor Trap Vector */
#define CSR_SATP        0x180   /* Supervisor Address Translation */

/* RISC-V CSR 접근 인라인 어셈블리 */
#define csr_read(csr)  ({                 unsigned long __v;                      asm volatile("csrr %0, " __stringify(csr)         : "=r"(__v) :: "memory");          __v; })

/* satp 레지스터: 페이지 테이블 모드(Sv39/48/57) + ASID + PPN */
/* Privileged ISA Vol.II Section 4.1.11 참조 */
#define SATP_MODE_SV39  (8UL << 60)
#define SATP_MODE_SV48  (9UL << 60)
#define SATP_MODE_SV57  (10UL << 60)

관련 문서

어셈블리와 관련된 다른 주제를 더 깊이 이해하고 싶다면 다음 문서를 참고하세요.

• SIMD 명령과 커널 개발 — SSE/AVX/AVX-512/AMX 레지스터, kernel_fpu_begin
• CPUID 명령어 심화 — x86 피처 비트, 런타임 CPU 탐지
• 부팅 과정 — 부팅 어셈블리 코드
• Atomic 연산 — 어셈블리 원자 연산
• 메모리 배리어 — 어셈블리 배리어
• 최적화 — 어셈블리 최적화
• x86-64 ISA 심화 — x86-64 명령어 셋 아키텍처 상세
• ARM64 ISA 심화 — AArch64 명령어 셋 아키텍처 상세
• RISC-V ISA 심화 — RISC-V 명령어 셋 아키텍처 상세
• GNU Assembler (as) 완전 가이드 — GAS 지시자 전체 참조
• 커널 보안 — Spectre/Meltdown 완화 정책