용어 요약 (Glossary)

리눅스 커널 핵심 용어를 간결하게 정리한 용어집입니다. 알파벳/가나다 순으로 분류하여 빠르게 참조할 수 있습니다.

학습 지도

# 용어 학습 루프 예시
$ grep -n "RCU" pages/glossary.html
$ xdg-open pages/rcu.html
$ rg "rcu_read_lock|synchronize_rcu" -n /usr/src/linux

일반 (General)

ABI (Application Binary Interface)

컴파일된 바이너리가 커널 또는 라이브러리와 상호작용하는 인터페이스 규약입니다. 레지스터(Register) 사용, 호출 규약(Calling Convention), 구조체 레이아웃, 시스템 콜 번호, 공개 구조체 크기와 정렬까지 포함하는 바이너리 수준 계약입니다. 커널은 사용자 공간(User Space) ABI의 하위 호환성을 엄격히 유지합니다.

ABI는 시스템 콜만 뜻하지 않으며, include/uapi/ 헤더와 ioctl 구조체, compat ABI까지 함께 봐야 합니다. 자세한 설명은 ABI 문서를 참고하세요.

ACPI (Advanced Configuration and Power Interface)

OS가 하드웨어 구성, 전원 관리(Power Management), 열 관리(Thermal Management) 등을 제어할 수 있도록 하는 펌웨어(Firmware) 표준. DSDT/SSDT 테이블에 AML 바이트코드로 하드웨어 정보를 기술합니다. → UEFI

API (Application Programming Interface)

소스 코드 수준의 인터페이스 규약. 커널 내부 API(드라이버 작성용)와 사용자 공간 API(시스템 콜)로 구분됩니다. 커널 내부 API는 버전 간 변경될 수 있으나, 사용자 공간 API(syscall)는 절대 깨뜨리지 않습니다.

Bootloader (부트로더(Bootloader))

시스템 전원 투입 후 커널 이미지를 메모리에 로드하고 실행하는 프로그램. x86에서는 GRUB이, ARM/임베디드에서는 U-Boot이 대표적입니다. 커널 커맨드 라인 파라미터 전달, initramfs 로드, Device Tree 전달 등을 담당합니다. → 부팅 과정(Boot Process)

container_of()

구조체의 내장 멤버 포인터에서 부모 구조체의 시작 주소를 역추적(Backtrace)하는 매크로(Macro). offsetof()를 이용하여 멤버 오프셋(Offset)만큼 뺀 주소를 반환합니다. 연결 리스트(Linked List), 콜백(Callback) 구조 등 커널 전반에서 광범위하게 사용됩니다.

Device Tree

하드웨어 구성 정보를 기술하는 데이터 구조. 주로 ARM/RISC-V에서 사용하며, .dts 소스를 dtc로 컴파일하여 .dtb 바이너리를 생성합니다. 부트로더가 커널에 전달합니다. → 디바이스 드라이버

EXPORT_SYMBOL

커널 심볼(함수·변수)을 다른 모듈에서 사용할 수 있도록 공개하는 매크로. EXPORT_SYMBOL()은 모든 모듈에, EXPORT_SYMBOL_GPL()은 GPL 호환 모듈에만 공개합니다. 내보내지 않은 심볼은 외부 모듈에서 링크할 수 없습니다.

GPL (GNU General Public License)

리눅스 커널이 채택한 오픈소스 라이선스 (GPLv2). 커널 소스를 수정·배포할 때 소스 코드를 공개해야 합니다. MODULE_LICENSE("GPL")을 선언해야 GPL 전용 심볼을 사용할 수 있습니다.

__init / __exit

커널 초기화·정리 섹션을 지정하는 매크로. __init으로 표시된 함수·데이터는 부팅 초기화 완료 후 메모리에서 해제됩니다. __exit은 모듈 언로드 시 호출되며, 빌트인 커널에서는 컴파일에서 제외됩니다.

Initramfs / Initrd

부팅 초기 루트 파일시스템으로 사용되는 메모리 기반 파일시스템. 커널이 실제 루트 파일시스템을 마운트(Mount)하기 전에 필요한 드라이버·스크립트를 로드합니다. initramfs는 cpio 아카이브, initrd는 RAM 디스크 이미지 방식입니다. → 부팅 과정

Kconfig

커널 빌드 설정 시스템. Kconfig 파일에 설정 옵션을 정의하고 make menuconfig 등으로 .config를 생성합니다. CONFIG_* 매크로로 조건부 컴파일을 제어합니다. → 빌드 시스템(Build System)

Kernel Module (커널 모듈(Kernel Module))

커널에 동적으로 로드·언로드할 수 있는 코드 단위. insmod/rmmod으로 수동 로드/언로드하거나 modprobe로 의존성을 자동 해결합니다. 드라이버, 파일시스템, 네트워크 프로토콜 등을 모듈로 배포할 수 있습니다. → 커널 모듈

Kernel Panic

커널이 복구 불가능한 치명적 오류를 감지했을 때 시스템을 정지시키는 메커니즘. panic() 함수로 트리거되며 콘솔에 오류 메시지와 스택 트레이스를 출력합니다. panic=N 부트 파라미터로 N초 후 자동 재부팅을 설정할 수 있습니다.

Kernel

운영체제의 핵심 구성 요소로, 하드웨어 자원 관리와 사용자 프로그램에 서비스를 제공하는 소프트웨어. 리눅스 커널은 모놀리식(monolithic) 구조이며, 모듈로 기능을 동적 확장할 수 있습니다. → 커널 아키텍처

kobject / kset

커널 디바이스 모델의 기반 구조체. kobject는 참조 카운팅, sysfs 노출, uevent 통지를 제공하며, kset은 kobject의 컨테이너(Container) 역할을 합니다. 디바이스, 드라이버, 버스(Bus) 등 모든 커널 객체의 공통 인프라입니다. → 디바이스 드라이버

Kernel Space / User Space

CPU 특권 모드로 분리된 두 가지 실행 환경. 커널 공간(Kernel Space)은 ring 0(x86) 또는 EL1(ARM64)에서 모든 하드웨어에 접근 가능하고, 사용자 공간은 ring 3/EL0에서 시스템 콜을 통해서만 커널 서비스를 요청합니다.

LTS (Long Term Support)

장기 지원 커널 버전. 일반 커널이 약 2~3개월 지원되는 것과 달리 LTS는 2~6년간 보안·버그 수정 패치(Patch)를 받습니다. 임베디드·서버 환경에서 주로 채택합니다.

Mainline

Linus Torvalds가 관리하는 공식 커널 소스 트리. 모든 커널 개발은 mainline에 통합(merge)되는 것을 목표로 합니다. git.kernel.org에서 관리됩니다.

Makefile

Kbuild 시스템의 빌드 규칙 파일. 각 디렉토리의 Makefile에서 obj-y, obj-m 변수로 빌드 대상을 지정합니다. → 빌드 시스템

Namespace (네임스페이스(Namespace))

커널 자원을 프로세스 그룹별로 격리(Isolation)하는 메커니즘. PID, NET, MNT, UTS, IPC, USER, cgroup, time 네임스페이스가 있습니다. 컨테이너 기술의 핵심 기반으로, clone()/unshare() 시스템 콜로 생성합니다. → 네임스페이스

Microkernel

최소한의 기능(IPC, 스케줄링, 메모리 관리(Memory Management))만 커널에 두고 나머지를 사용자 공간 서버로 분리하는 설계. Mach, L4, QNX 등이 해당합니다. 리눅스는 모놀리식이지만 모듈 시스템으로 유연성을 제공합니다.

Monolithic Kernel

모든 커널 서비스(드라이버, 파일시스템, 네트워크 등)가 하나의 주소 공간(Address Space)에서 실행되는 설계. 리눅스가 이 구조를 채택하고 있으며, 함수 호출로 통신하므로 마이크로커널 대비 성능이 유리합니다.

Patch

소스 코드 변경 사항을 기술한 diff 형식의 파일. 커널 개발에서는 git format-patch로 패치를 생성하고 메일링 리스트에 제출합니다. → 개발 도구

printk

커널 로그 메시지를 출력하는 함수. KERN_EMERG부터 KERN_DEBUG까지 8단계 로그 레벨을 지원합니다. 출력은 커널 링 버퍼(Ring Buffer)에 저장되며 dmesg 명령이나 /dev/kmsg로 조회합니다. pr_info(), pr_err() 등 래퍼 매크로가 주로 사용됩니다.

POSIX (Portable Operating System Interface)

IEEE가 정의한 유닉스 호환 OS 표준 인터페이스. 리눅스는 POSIX를 대부분 준수하지만 공식 인증을 받지는 않았습니다. 시스템 콜, 시그널(Signal), 스레드(Thread) API 등이 POSIX 기반입니다.

System Call (시스템 콜)

사용자 공간 프로그램이 커널 서비스를 요청하는 인터페이스. x86_64에서 syscall 명령어로 진입하며, sys_call_table에서 핸들러(Handler)를 찾아 실행합니다. read(), write(), ioctl() 등이 대표적입니다. → 커널 아키텍처

cgroups (Control Groups)

프로세스 그룹의 CPU·메모리·I/O·네트워크 자원을 계층적으로 제한·격리하는 커널 기능. cgroup v2는 통합 계층 구조를 사용합니다. 컨테이너(Docker, LXC)와 systemd 서비스 관리의 기반이 됩니다. → 컨테이너

container_of() 코드 예제

/* include/linux/container_of.h */
#define container_of(ptr, type, member) ({                \
    const typeof( ((type *)0)->member ) *__mptr = (ptr); \
    (type *)( (char *)__mptr - offsetof(type, member) ); \
})

/* 사용 예: list_head에서 부모 구조체 접근 */
struct my_device {
    int id;
    struct list_head list;   /* 연결 리스트 노드 */
    char name[32];
};

/* list_head 포인터에서 my_device 포인터 획득 */
struct my_device *dev = container_of(pos, struct my_device, list);

ABI vs API vs syscall 비교

메모리 (Memory)

Buddy Allocator

2의 거듭제곱 단위(1, 2, 4, …, 2^(MAX_ORDER-1) 페이지(Page))로 물리 페이지를 할당·해제하는 커널 기본 할당자. 인접한 같은 크기 블록(버디)을 합병하여 외부 단편화(Fragmentation)를 줄입니다. /proc/buddyinfo로 현재 상태를 확인할 수 있습니다. → 메모리 관리

CMA (Contiguous Memory Allocator)

DMA 등에 필요한 물리적으로 연속된 큰 메모리 영역을 할당하는 메커니즘. 미리 예약한 영역을 평시에는 이동 가능 페이지(movable)로 활용하다가, 할당 요청 시 페이지를 이동시켜 연속 공간을 확보합니다. → 메모리 관리

Copy-on-Write (COW)

fork() 시 부모·자식 프로세스가 동일한 물리 페이지를 공유하다가, 한쪽이 쓰기를 시도하면 그때서야 페이지를 복사하는 기법. 메모리 사용량과 fork 오버헤드(Overhead)를 크게 줄입니다.

Demand Paging

페이지를 실제로 접근하는 시점에 비로소 물리 메모리(Physical Memory)를 할당하는 지연(lazy) 할당 기법. 처음 접근 시 페이지 폴트(Page Fault)가 발생하면 커널이 물리 페이지를 매핑(Mapping)합니다. 메모리 오버커밋과 프로세스 빠른 생성을 가능하게 합니다.

folio

하나 이상의 연속 페이지를 묶은 compound page의 추상화 단위 (커널 5.16+). 기존 struct page의 tail page 혼동 문제를 해결하며, 페이지 캐시(Page Cache)·대규모 할당에서 사용됩니다. folio_get(), folio_put()으로 참조를 관리합니다. → 메모리 관리

GFP Flags

메모리 할당 시 동작을 제어하는 플래그. GFP_KERNEL(sleep 가능 일반 할당), GFP_ATOMIC(sleep 불가 인터럽트 컨텍스트용), GFP_DMA(DMA 영역), __GFP_NOWARN 등을 조합하여 할당 컨텍스트와 제약을 지정합니다. → 메모리 관리

Huge Pages

기본 4KB보다 큰 페이지 크기(2MB, 1GB)를 사용하여 TLB 미스를 줄이는 기법. hugetlbfs로 명시적으로 사용하거나, THP(Transparent Huge Pages)로 자동 적용할 수 있습니다. → 메모리 관리

Page Reclaim / kswapd

메모리 부족 시 사용 빈도가 낮은 페이지를 회수하는 커널 메커니즘. kswapd는 per-node 커널 스레드(Kernel Thread)로 백그라운드 회수를 수행하고, 긴급 시 직접 회수(direct reclaim)가 호출 경로에서 동기적으로 실행됩니다. LRU 리스트 기반으로 active/inactive 페이지를 관리합니다. → 메모리 관리

kmalloc / vmalloc

kmalloc()은 물리적으로 연속된 메모리를 할당(Slab 할당자 사용). vmalloc()은 가상 주소 공간에서만 연속인 메모리를 할당합니다. DMA가 필요하면 kmalloc, 큰 버퍼(Buffer)가 필요하면 vmalloc을 사용합니다. → 메모리 관리

Memory Compaction

물리 메모리 단편화를 해소하기 위해 이동 가능 페이지를 한쪽으로 밀어 연속된 빈 영역을 확보하는 커널 메커니즘. kcompactd 스레드가 백그라운드로 수행하며, 대규모 연속 할당(huge page) 성공률을 높입니다. → 메모리 관리

Memory Barrier (메모리 배리어(Memory Barrier))

CPU의 메모리 접근 순서를 보장하는 명령어. SMP 환경에서 다른 CPU가 메모리 변경을 올바른 순서로 관찰하도록 강제합니다. mb(), rmb(), wmb(), smp_mb() 등이 있습니다. → Atomic 연산

mm_struct

프로세스의 전체 가상 메모리(Virtual Memory) 상태를 관리하는 구조체. 페이지 테이블(Page Table) 포인터(pgd), VMA 리스트, mmap 영역, brk 위치, RSS/VM 카운터 등을 포함합니다. task_struct→mm으로 접근하며, 커널 스레드는 mm이 NULL입니다.

mmap

파일이나 디바이스를 프로세스의 가상 주소 공간에 매핑하는 시스템 콜. 파일 I/O 없이 메모리 접근으로 읽기/쓰기가 가능하며, 공유 메모리(IPC), 익명 매핑 등에도 사용됩니다.

NUMA (Non-Uniform Memory Access)

멀티소켓 시스템에서 CPU마다 로컬 메모리를 갖는 아키텍처. 로컬 노드 접근이 원격 노드보다 빠르므로 메모리 할당 정책이 성능에 큰 영향을 미칩니다. → NUMA

OOM Killer

시스템 메모리가 완전히 고갈되었을 때 커널이 프로세스를 강제 종료하여 메모리를 회수하는 메커니즘. oom_score에 따라 종료 대상을 선정합니다. /proc/<pid>/oom_score_adj로 우선순위(Priority)를 조정할 수 있습니다.

PFN (Page Frame Number)

물리 페이지의 고유 인덱스 번호. 물리 주소(Physical Address)를 페이지 크기(보통 4KB)로 나눈 값입니다. page_to_pfn()/pfn_to_page() 매크로로 struct page와 상호 변환합니다. 메모리 맵(Memory Map), NUMA 노드 매핑 등에서 핵심적으로 사용됩니다.

Page (페이지)

가상 메모리의 최소 관리 단위. x86_64에서 기본 4KB. 커널은 struct page로 각 물리 페이지를 추적하며, Buddy Allocator로 할당·해제합니다. → 메모리 관리

Page Table (페이지 테이블)

가상 주소(Virtual Address)를 물리 주소로 변환하는 다단계 매핑 테이블. x86_64는 4~5단계(PGD → P4D → PUD → PMD → PTE), ARM64는 최대 4단계를 사용합니다. 커널은 프로세스마다 별도의 페이지 테이블을 관리합니다.

Swap

물리 메모리 부족 시 익명 페이지(anonymous page)를 디스크 파티션이나 파일로 내보내는 메커니즘. 메모리 용량을 초과하는 워크로드를 처리할 수 있게 하지만 디스크 I/O로 인한 성능 저하가 큽니다. vm.swappiness로 적극성을 조절합니다.

Slab Allocator

동일 크기 객체를 효율적으로 할당·해제하는 캐시(Cache) 기반 메모리 할당자(Memory Allocator). 내부 단편화를 줄이고 생성/소멸 비용을 낮춥니다. 리눅스는 SLUB이 기본이며 SLAB, SLOB(제거됨)도 있었습니다. → 메모리 관리

TLB (Translation Lookaside Buffer)

페이지 테이블 조회 결과를 캐싱하는 CPU 하드웨어. TLB 미스가 발생하면 페이지 테이블 워크가 필요하므로 성능이 저하됩니다. 컨텍스트 스위칭(Context Switching) 시 TLB 플러시(Flush)가 발생할 수 있습니다.

VMA (vm_area_struct)

프로세스 가상 주소 공간의 연속된 영역 하나를 표현하는 구조체. 시작·끝 주소, 접근 권한(rwx), 매핑된 파일 정보를 포함합니다. /proc/<pid>/maps의 각 줄이 하나의 VMA에 대응합니다. → 메모리 관리

Virtual Memory (가상 메모리)

각 프로세스에게 독립된 주소 공간을 제공하는 메모리 관리 기법. MMU가 가상 주소를 물리 주소로 변환하며, 이를 통해 메모리 보호, 페이지 스왑(Swap), 메모리 매핑 등이 가능합니다. → 메모리 관리

zswap

스왑 I/O를 줄이기 위해 스왑 대상 페이지를 압축하여 메모리 풀에 보관하는 커널 기능. 디스크 스왑보다 빠르며 압축 비율에 따라 실질적인 메모리 용량을 늘립니다. zpool(zbud, z3fold, zsmalloc) 백엔드를 선택할 수 있습니다.

ZONE_DMA / ZONE_NORMAL / ZONE_HIGHMEM

물리 메모리를 용도별로 나눈 영역. ZONE_DMA는 ISA DMA 제약(16MB 이하), ZONE_NORMAL은 커널이 직접 매핑하는 영역, ZONE_HIGHMEM은 32비트에서 896MB 이상 메모리(64비트에서는 불필요). → 메모리 관리

메모리 할당 함수 비교

GFP 플래그와 할당 코드 예제

/* 프로세스 컨텍스트에서의 일반 할당 */
void *buf = kmalloc(4096, GFP_KERNEL);
if (!buf)
    return -ENOMEM;

/* 인터럽트 핸들러에서의 할당 — sleep 불가 */
void *irq_buf = kmalloc(256, GFP_ATOMIC);

/* 큰 버퍼: vmalloc 사용 (물리적 비연속 OK) */
void *big = vmalloc(1 << 20);  /* 1MB */

/* Slab 캐시로 고빈도 객체 할당 */
static struct kmem_cache *my_cache;
my_cache = kmem_cache_create("my_obj",
    sizeof(struct my_obj), 0,
    SLAB_HWCACHE_ALIGN, NULL);
struct my_obj *obj = kmem_cache_alloc(my_cache, GFP_KERNEL);

프로세스 / 스케줄링 (Process / Scheduling)

Cgroup CPU Controller

cgroup v2의 CPU 컨트롤러로, 프로세스 그룹의 CPU 시간을 제한·분배합니다. cpu.max로 대역폭(Bandwidth) 제한(bandwidth throttling), cpu.weight로 상대적 가중치를 설정합니다. 컨테이너 환경의 CPU 자원 격리에 핵심적으로 사용됩니다. → 컨테이너

Completion

작업 완료를 대기·통지하는 동기화 프리미티브. wait_for_completion()으로 대기하고 complete()로 통지합니다. 뮤텍스(Mutex)와 달리 소유권 개념이 없어 한 컨텍스트에서 시작하고 다른 컨텍스트에서 완료를 알릴 수 있습니다.

Context Switch (컨텍스트 스위칭)

CPU가 현재 실행 중인 태스크(Task)의 상태(레지스터, 스택 포인터 등)를 저장하고 다른 태스크의 상태를 복원하여 실행을 전환하는 과정. 오버헤드가 있으므로 최소화가 성능 최적화의 핵심입니다. → 프로세스 관리

CPU Affinity

태스크 또는 인터럽트를 특정 CPU(코어)에 바인딩하는 설정. sched_setaffinity() 시스템 콜이나 taskset 명령으로 프로세스의 CPU 마스크를 지정합니다. 캐시 친화성 향상, NUMA 로컬리티 최적화에 활용됩니다.

Kthread (커널 스레드)

kthread_create()로 생성하는 커널 전용 스레드. 사용자 공간 주소 공간이 없으며(mm = NULL) 커널 코드만 실행합니다. kswapd, ksoftirqd, kworker 등이 대표적인 커널 스레드입니다.

Load Balancing (스케줄러(Scheduler))

멀티코어 시스템에서 CPU 간 태스크 부하를 균등하게 분배하는 스케줄러 기능. 스케줄링 도메인(sched_domain) 계층 구조를 따라 주기적으로 바쁜 CPU의 태스크를 유휴 CPU로 마이그레이션합니다. → 프로세스 관리

Nice / Priority

프로세스 스케줄링 우선순위. nice 값은 -20(최고)~19(최저)이며, CFS에서 vruntime 증가 속도에 영향을 줍니다. 실시간(Real-time) 프로세스는 별도의 rt_priority(1~99)를 사용합니다.

PID / TGID

PID는 각 태스크(스레드)의 고유 식별자, TGID(Thread Group ID)는 스레드 그룹의 대표 PID(= 메인 스레드의 PID). 사용자 공간에서 getpid()는 TGID를, gettid()는 PID를 반환합니다.

PSI (Pressure Stall Information)

CPU·메모리·I/O 자원의 부족 정도를 정량적으로 측정하는 커널 기능 (4.20+). /proc/pressure/{cpu,memory,io}에서 some/full 지연 비율을 확인합니다. cgroup v2와 연동하여 컨테이너별 자원 압력 모니터링에 사용됩니다.

Preemption (선점(Preemption))

실행 중인 태스크를 중단하고 더 높은 우선순위의 태스크를 실행하는 것. 커널 설정에 따라 PREEMPT_NONE(서버용), PREEMPT_VOLUNTARY, PREEMPT(데스크탑/RT)으로 선점 수준을 조절합니다.

Process (프로세스)

실행 중인 프로그램의 인스턴스. 독립된 가상 주소 공간, 파일 디스크립터(File Descriptor) 테이블, 시그널 핸들러 등을 갖습니다. fork()로 생성하고 exec()로 새 프로그램을 로드합니다. → 프로세스 관리

Runqueue

CPU별로 실행 가능한 태스크를 관리하는 자료구조(struct rq). CFS의 경우 레드-블랙 트리로 태스크를 vruntime 순으로 정렬하여 다음 실행 태스크를 O(1)에 선택합니다.

vruntime

CFS(Completely Fair Scheduler)에서 태스크의 가상 실행 시간. 실제 실행 시간을 nice 가중치로 보정한 값으로, vruntime이 가장 작은 태스크가 다음에 실행됩니다. 모든 태스크의 vruntime을 균등하게 유지하여 공정성(Fairness)을 보장합니다. → 프로세스 관리

Scheduler (스케줄러) — CFS / EEVDF

어떤 태스크를 언제 CPU에서 실행할지 결정하는 커널 서브시스템. CFS(Completely Fair Scheduler)는 vruntime 기반 공정 스케줄링을 제공하며, 6.6부터 EEVDF(Earliest Eligible Virtual Deadline First)로 대체되었습니다. → 프로세스 관리

Signal (시그널)

프로세스에 비동기 이벤트를 통지하는 메커니즘. SIGKILL(강제 종료), SIGTERM(종료 요청), SIGSEGV(세그멘테이션 폴트) 등이 있습니다. kill() 시스템 콜 또는 커널 내부에서 전달됩니다.

Task (task_struct)

커널이 프로세스/스레드를 나타내는 핵심 자료구조. 스케줄링 정보, 메모리 디스크립터, 파일 테이블, 시그널 정보 등을 포함합니다. 모든 태스크는 task_struct로 관리됩니다. → 프로세스 관리

Thread (스레드)

같은 주소 공간을 공유하는 실행 흐름. 리눅스에서는 clone() 시스템 콜로 생성하며, 프로세스와 동일하게 task_struct로 표현된다(1:1 스레딩 모델).

Wait Queue

특정 조건이 충족될 때까지 태스크를 대기(sleep)시키는 메커니즘. wait_event() / wake_up() 쌍으로 사용합니다. I/O 완료 대기, 리소스 가용 대기 등에 널리 쓰입니다.

Workqueue

프로세스 컨텍스트에서 지연 작업을 실행하는 메커니즘. kworker 커널 스레드가 큐에 쌓인 작업을 순차적으로 처리합니다. sleep이 가능하므로 softirq/tasklet보다 유연합니다. INIT_WORK()/schedule_work()로 사용합니다.

task_struct 핵심 필드와 프로세스 상태

/* include/linux/sched.h — 핵심 필드 요약 */
struct task_struct {
    unsigned int           __state;         /* 프로세스 상태 */
    int                    prio;            /* 동적 우선순위 */
    int                    static_prio;     /* nice → 정적 우선순위 */
    pid_t                  pid;             /* 태스크 ID */
    pid_t                  tgid;            /* 스레드 그룹 ID */
    struct mm_struct       *mm;              /* 메모리 디스크립터 */
    struct files_struct    *files;           /* 열린 파일 테이블 */
    struct signal_struct   *signal;          /* 시그널 정보 */
    struct sched_entity    se;               /* CFS 스케줄링 엔티티 */
    /* ... 수백 개 필드 생략 ... */
};

/* 프로세스 상태 값 */
#define TASK_RUNNING          0x00  /* 실행 중 / 실행 대기 */
#define TASK_INTERRUPTIBLE    0x01  /* 시그널로 깨울 수 있는 sleep */
#define TASK_UNINTERRUPTIBLE  0x02  /* I/O 대기 등 깨울 수 없는 sleep */
#define __TASK_STOPPED        0x04  /* SIGSTOP으로 정지 */
#define EXIT_ZOMBIE           0x20  /* 종료, wait() 대기 */

동기화 (Synchronization)

Barrier (컴파일러 배리어)

컴파일러가 명령어 순서를 재정렬하는 것을 방지하는 지시어. barrier() 매크로는 컴파일러에게 배리어 전후의 메모리 접근 순서를 유지하도록 강제합니다. CPU 배리어(mb() 등)와 구분되며, 단일 CPU에서도 필요할 수 있습니다.

Atomic Operations (원자적 연산(Atomic Operation))

CPU 수준에서 분할 불가능한 연산. atomic_t 타입과 atomic_add(), atomic_cmpxchg() 등의 함수로 잠금(Lock) 없이 변수를 안전하게 조작합니다. 참조 카운팅에 주로 사용됩니다. → Atomic 연산

Deadlock (교착 상태(Deadlock))

두 개 이상의 태스크가 서로가 가진 잠금을 기다리며 무한 대기에 빠지는 상태. 잠금 획득 순서를 일관되게 유지하면 예방할 수 있습니다. lockdep으로 런타임 감지가 가능합니다. → 디버깅

Lock Contention

여러 CPU/스레드가 동일한 잠금을 획득하려 경쟁하는 상황. 높은 contention은 심각한 성능 저하를 유발합니다. per-CPU 변수, RCU, 세분화된 잠금(fine-grained locking)으로 완화합니다.

Memory Ordering

멀티프로세서 환경에서 메모리 연산의 관찰 순서를 제어하는 규칙. acquire/release 시맨틱, 메모리 배리어, READ_ONCE()/WRITE_ONCE()로 컴파일러·CPU 재정렬을 방지합니다. → Atomic 연산

Mutex

상호 배제(mutual exclusion) 잠금. 경쟁 시 태스크를 sleep 시키므로 인터럽트 컨텍스트에서 사용 불가. spinlock보다 오래 유지하는 잠금에 적합합니다. → 동기화 기법

preempt_disable / preempt_enable

커널 선점(preemption)을 비활성화/재활성화하는 API. 임계 영역(Critical Section)에서 현재 태스크가 다른 태스크로 교체되는 것을 방지합니다. per-CPU 변수 접근, spinlock 내부 등에서 사용됩니다. 중첩 호출이 가능하며 카운터로 관리됩니다.

Per-CPU Variables

CPU마다 별도 복사본을 유지하는 변수. 잠금 없이 접근 가능하므로 캐시 바운싱과 lock contention을 제거합니다. DEFINE_PER_CPU(), get_cpu_var()로 사용합니다.

READ_ONCE / WRITE_ONCE

컴파일러 최적화(load/store 제거, 분할, 반복)를 방지하여 메모리 접근을 정확히 한 번만 수행하도록 강제하는 매크로. 락이 없는 공유 변수 접근에서 데이터 경쟁 문제를 방지합니다. volatile보다 의도가 명확하고 권장됩니다. → Atomic 연산

RCU (Read-Copy-Update)

읽기 측이 잠금 없이 접근하고, 쓰기 측이 복사본을 수정한 뒤 grace period 후 이전 데이터를 해제하는 동기화 기법. 읽기 빈도가 높은 자료구조(라우팅 테이블(Routing Table), 프로세스 리스트)에 최적입니다. → RCU

RW Lock (Read-Write Lock)

다수의 읽기와 단일 쓰기를 구분하여 동시성을 높이는 잠금. 읽기가 많은 경우 성능이 좋지만, 쓰기 기아(starvation) 문제가 있습니다. 커널에서는 rwlock_t와 rwsem이 있습니다. → 동기화 기법

Semaphore

카운팅 기반 동기화 프리미티브. 지정된 수만큼 동시 접근을 허용합니다. 커널에서는 대부분 mutex로 대체되었으며, 특수한 경우(제한된 리소스 풀)에만 사용합니다. → 동기화 기법

Seqlock

시퀀스 카운터 기반 잠금으로, 쓰기 측이 카운터를 증가시키고 읽기 측이 카운터 변화를 감지하여 재시도하는 방식. 쓰기가 드물고 읽기가 빈번한 경우에 적합합니다. jiffies 업데이트에 사용됩니다. → 동기화 기법

Spinlock

잠금을 획득할 때까지 CPU가 루프를 돌며 대기하는 잠금. 짧은 임계 영역에 적합하며, 인터럽트 컨텍스트에서도 사용 가능합니다. spin_lock_irqsave()로 인터럽트와 함께 보호할 수 있습니다. → 동기화 기법

futex (Fast Userspace Mutex)

빠른 사용자 공간 뮤텍스를 구현하는 시스템 콜. 경쟁이 없으면 사용자 공간에서 원자적 연산만으로 완료되고, 경쟁 시에만 커널 모드로 진입하여 대기합니다. glibc의 pthread_mutex_t와 pthread_cond_t의 기반입니다. → 동기화 기법

동기화 프리미티브 선택 가이드

동기화 코드 패턴 비교

/* ── spinlock: IRQ 안전 패턴 ── */
unsigned long flags;
spin_lock_irqsave(&lock, flags);
/* 임계 영역 — sleep 금지 */
spin_unlock_irqrestore(&lock, flags);

/* ── mutex: 프로세스 컨텍스트 전용 ── */
mutex_lock(&my_mutex);
/* 임계 영역 — sleep 가능 */
mutex_unlock(&my_mutex);

/* ── RCU: 읽기 측 무잠금 ── */
rcu_read_lock();
p = rcu_dereference(global_ptr);
/* p를 읽기 — 선점 비활성화만 */
rcu_read_unlock();

/* 쓰기 측: 복사 → 교체 → grace period 후 해제 */
new_p = kmalloc(sizeof(*new_p), GFP_KERNEL);
*new_p = *old_p;
new_p->field = new_val;
rcu_assign_pointer(global_ptr, new_p);
synchronize_rcu();
kfree(old_p);

파일시스템 (Filesystem)

Block Device (블록 디바이스)

고정 크기 블록 단위로 데이터를 읽고 쓰는 디바이스. 하드 디스크, SSD, NVMe 등이 해당합니다. 블록 I/O 레이어(struct bio)를 통해 요청이 처리됩니다.

Btrfs

B-tree 기반의 차세대 리눅스 파일시스템. COW, 스냅샷, 내장 RAID, 서브볼륨, 온라인 디프래그, 압축 등을 지원합니다. 엔터프라이즈·데스크탑 모두에서 사용이 증가하고 있습니다.

Direct I/O

페이지 캐시를 우회하여 사용자 버퍼와 디스크 간 직접 데이터를 전송하는 I/O 방식. O_DIRECT 플래그로 활성화하며, 데이터베이스처럼 자체 캐시를 가진 애플리케이션에서 이중 캐싱을 피하기 위해 사용합니다. 정렬 제약이 있습니다.

Dentry

디렉토리 엔트리(Directory Entry)를 표현하는 VFS 객체. 파일 이름과 inode의 매핑을 캐싱하여 경로 해석(path lookup)을 가속합니다. dcache에 LRU 방식으로 캐싱됩니다. → VFS

ext4

리눅스의 사실상 표준 파일시스템. 저널링(Journaling), 익스텐트 기반 할당, 지연 할당(delayed allocation), 다중 블록 할당 등을 지원합니다. 최대 1EB 볼륨, 16TB 파일 크기를 지원합니다.

file_operations

VFS 파일 연산 함수 포인터 테이블. open, read, write, mmap, ioctl, release 등의 콜백을 정의하여 파일시스템이나 디바이스 드라이버가 파일 연산을 구현합니다. struct file_operations로 선언합니다. → VFS

File Descriptor (파일 디스크립터)

프로세스가 열린 파일을 참조하는 정수 핸들. 프로세스별 files_struct의 fd 테이블에서 struct file을 가리킵니다. 0(stdin), 1(stdout), 2(stderr)이 기본 할당됩니다.

EOF (End of File)

파일의 끝을 나타내는 조건. read() 시스템 콜이 0을 반환하면 파일 끝에 도달했음을 의미합니다. 오류(-1 반환)와 구별해야 합니다. 파일 잠금(File Lock) 범위 표현에서는 파일 끝까지를 나타내는 특수 값(OFFSET_MAX)으로 사용됩니다.

Journaling (저널링)

파일시스템 메타데이터(또는 데이터)의 변경 사항을 먼저 저널(로그) 영역에 기록한 뒤 실제 위치에 반영하는 기법. 비정상 종료 시 저널을 재생(replay)하여 일관성을 복구합니다. ext4, XFS, Btrfs 등이 지원합니다.

Inode

파일의 메타데이터(권한, 크기, 타임스탬프, 데이터 블록 위치)를 저장하는 자료구조. 파일 이름은 dentry가, 실제 데이터 위치는 inode가 관리합니다. → inode 구조

NFS (Network File System)

네트워크를 통해 원격 서버의 파일시스템을 로컬에 마운트하여 접근하는 분산 파일시스템. 커널 NFS 클라이언트(nfs 모듈)와 서버(nfsd)가 모두 지원됩니다. NFSv4는 상태 기반(stateful) 프로토콜로 잠금과 위임(delegation)을 제공합니다.

Page Cache

디스크에서 읽은 파일 데이터를 메모리에 캐싱하는 계층. 동일 파일의 반복 읽기 성능을 크게 향상시킵니다. read()/write() 시 커널이 자동으로 관리합니다.

procfs

/proc에 마운트되는 가상 파일시스템(VFS). 프로세스 정보(/proc/<pid>), 커널 매개변수(/proc/sys), 하드웨어 정보 등을 파일 형태로 노출합니다. → procfs/sysfs

Superblock

마운트된 파일시스템의 전체 메타데이터(블록 크기, inode 수, 마운트 옵션 등)를 담는 VFS 객체. 각 마운트 포인트마다 하나의 struct super_block이 존재합니다. → VFS

sysfs

/sys에 마운트되는 가상 파일시스템. 커널 객체(디바이스, 드라이버, 버스)의 속성을 파일로 노출합니다. kobject 계층 구조를 반영합니다. → procfs/sysfs

tmpfs

메모리(RAM) 기반의 임시 파일시스템. /tmp, /run 등에 사용되며, 디스크 I/O 없이 빠릅니다. 시스템 재부팅 시 데이터가 사라집니다. swap을 사용할 수 있어 물리 메모리 이상을 저장 가능합니다.

Writeback

페이지 캐시의 더티(dirty) 페이지를 디스크에 기록하는 과정. pdflush/flush-* 스레드가 주기적으로 또는 더티 비율 임계치 도달 시 백그라운드로 수행합니다. sync() 시스템 콜이나 fsync()로 즉시 기록을 강제할 수 있습니다.

VFS (Virtual Filesystem Switch)

다양한 파일시스템(ext4, Btrfs, NFS 등)을 통합하는 추상화 계층. superblock, inode, dentry, file 네 가지 핵심 객체로 구성됩니다. 사용자 공간은 파일시스템 종류에 관계없이 동일한 API를 사용합니다. → VFS

file_operations 등록 패턴

/* 캐릭터 디바이스 드라이버의 file_operations 등록 예 */
static ssize_t my_read(struct file *filp,
    char __user *buf, size_t count, loff_t *ppos)
{
    return simple_read_from_buffer(buf, count, ppos,
        my_data, my_data_len);
}

static const struct file_operations my_fops = {
    .owner   = THIS_MODULE,
    .open    = my_open,
    .read    = my_read,
    .write   = my_write,
    .release = my_release,
    .llseek  = default_llseek,
};

주요 파일시스템 비교

XFS

SGI에서 개발한 대용량 고성능 저널링 파일시스템. 64비트 아키텍처, 익스텐트 기반 할당, 지연 할당, B+ 트리 메타데이터, 온라인 리사이즈를 지원합니다. 대규모 파일과 고병렬 I/O에 강하며 RHEL 7+ 기본 파일시스템입니다.

보안 (Security)

LSM (Linux Security Module)

커널에 보안 정책을 플러그인 형태로 삽입하는 프레임워크. 시스템 콜 경로의 훅(hook) 포인트에서 접근 제어(Access Control)를 수행합니다. SELinux, AppArmor, Smack 등이 LSM으로 구현됩니다. → 보안 서브시스템

SELinux (Security-Enhanced Linux)

NSA가 개발한 레이블 기반 MAC(Mandatory Access Control) 보안 정책 시스템. 모든 객체(파일, 프로세스, 소켓(Socket))에 레이블을 붙이고 정책 규칙에 따라 접근을 허용·거부합니다. 안드로이드와 RHEL 계열의 기본 보안 모듈입니다. → 보안 서브시스템

BPF LSM

eBPF 프로그램을 LSM 훅에 연결하여 동적으로 보안 정책을 적용하는 프레임워크 (5.7+). SELinux/AppArmor처럼 정적 정책이 아닌 런타임에 프로그래밍 가능한 보안 정책을 구현할 수 있습니다. → 보안 서브시스템

AppArmor

경로 기반 MAC 보안 정책 시스템. SELinux보다 설정이 간단하며, 프로그램별로 허용할 파일 경로와 네트워크 접근을 프로파일로 정의합니다. Ubuntu·Debian 계열에서 기본 보안 모듈로 사용됩니다. → 보안 서브시스템

Secure Boot

UEFI 펌웨어가 부팅 체인(부트로더, 커널, 모듈)의 디지털 서명을 검증하여 무결성(Integrity)을 보장하는 보안 메커니즘. 서명되지 않거나 변조된 코드의 실행을 차단합니다. 커널은 CONFIG_MODULE_SIG으로 모듈 서명 검증(Signature Verification)을 지원합니다. → 보안 부팅

Seccomp (Secure Computing Mode)

프로세스가 사용할 수 있는 시스템 콜을 필터링하는 메커니즘. BPF 프로그램으로 허용·거부할 syscall 목록을 정의합니다. 컨테이너 런타임(Docker, containerd)과 브라우저 샌드박스(Sandbox)에서 공격 표면을 줄이는 데 사용됩니다. → 보안 서브시스템

Linux Capabilities (리눅스 권한)

전통적인 root(UID 0) 권한을 세분화한 권한 단위. CAP_NET_ADMIN(네트워크 관리), CAP_SYS_PTRACE(프로세스 추적) 등 수십 가지 권한으로 나누어 최소 권한 원칙을 적용합니다. → 보안 부팅

KASLR (Kernel Address Space Layout Randomization)

커널 이미지가 메모리에 로드되는 주소를 무작위화하여 exploit을 완화하는 기법. 공격자가 커널 심볼 주소를 예측하기 어렵게 만듭니다. CONFIG_RANDOMIZE_BASE로 활성화하며, 부팅마다 다른 오프셋을 사용합니다. → 커널 취약점(Vulnerability)

User Namespace

UID/GID 매핑을 격리하여 컨테이너 내부에서 root 권한을 갖지만 호스트에서는 비특권 사용자로 동작하게 하는 네임스페이스. /proc/<pid>/uid_map으로 매핑을 설정합니다. 권한 없는 컨테이너(rootless container)의 기반입니다. → 네임스페이스

CVE / Security Patch (취약점 관리)

CVE(Common Vulnerabilities and Exposures)는 공개 보안 취약점의 표준 식별 체계. 커널 보안 취약점은 security@kernel.org에 비공개 보고 후 패치를 준비하고 배포합니다. LTS 커널은 CVE 패치를 백포트(backport)하여 안정 버전에 적용합니다. → 커널 취약점

네트워킹 (Networking)

Bonding / Teaming

여러 물리 네트워크 인터페이스를 하나의 논리 인터페이스로 결합하여 대역폭 증가 또는 장애 복구(failover)를 구현하는 기술. 커널의 bonding 드라이버는 7가지 모드(balance-rr, active-backup 등)를 지원합니다.

BPF / eBPF

커널 내에서 안전하게 실행되는 프로그래밍 프레임워크. 원래 패킷(Packet) 필터링(Berkeley Packet Filter)에서 출발하여, 현재는 네트워킹, 보안, 트레이싱, 스케줄링 등 범용으로 확장되었습니다. verifier가 안전성을 보증합니다. → BPF/XDP

Connection Tracking (Conntrack)

Netfilter 프레임워크의 상태 기반 패킷 추적 시스템. 각 연결의 상태(NEW, ESTABLISHED, RELATED, INVALID)를 추적하여 상태 기반 방화벽(Firewall)과 NAT를 구현합니다. conntrack 명령으로 추적 테이블을 조회합니다. → 네트워크 스택(Network Stack)

iptables / nftables

Netfilter 프레임워크 기반의 패킷 필터링·NAT 도구. iptables는 레거시, nftables는 후속 도구로 통합된 문법과 더 나은 성능을 제공합니다. → 네트워크 스택

net_device

커널에서 네트워크 인터페이스를 표현하는 핵심 구조체. 인터페이스 이름, MAC 주소, MTU, 통계, 전송/수신 콜백 등을 포함합니다. alloc_netdev()/register_netdev()로 등록하며 ip link 명령으로 관리합니다. → 네트워크 스택

Netfilter

커널 네트워크 스택의 훅(hook) 포인트에서 패킷을 가로채 처리하는 프레임워크. 방화벽, NAT, 패킷 맹글링 등에 사용됩니다. PREROUTING, INPUT, FORWARD, OUTPUT, POSTROUTING 5개 훅을 제공합니다. → 네트워크 스택

Netlink

커널과 사용자 공간 프로세스 간 양방향 통신을 위한 소켓 기반 IPC 메커니즘. 라우팅 테이블 관리(NETLINK_ROUTE), 감사(NETLINK_AUDIT), 네트워크 설정 등에 사용됩니다. ip 명령(iproute2)이 Netlink를 기반으로 동작합니다.

Network Namespace

네트워크 스택(인터페이스, 라우팅 테이블, 방화벽 규칙)을 격리하는 네임스페이스. 컨테이너 네트워킹의 기반이 됩니다. ip netns로 관리합니다. → 네임스페이스

Routing Table

패킷의 목적지 주소에 따라 다음 홉(next hop)과 출력 인터페이스를 결정하는 테이블. FIB(Forwarding Information Base)로 구현되며, 정책 라우팅(Routing)과 ECMP를 지원합니다. → 라우팅

sk_buff

커널 네트워크 스택에서 패킷 데이터를 담는 핵심 자료구조. 헤더 조작을 위한 push/pull 연산, 비선형 데이터(frag_list, skb_shared_info)를 지원합니다. → sk_buff

Socket (소켓)

네트워크 통신의 끝점(endpoint). AF_INET(IPv4), AF_INET6(IPv6), AF_UNIX(로컬 IPC) 등의 주소 패밀리와 SOCK_STREAM(TCP), SOCK_DGRAM(UDP) 등의 타입으로 구분됩니다. → 네트워크 스택

TSO / LRO

TSO(TCP Segmentation Offload)는 TCP 세그멘테이션을 NIC 하드웨어로 오프로드하여 CPU 부하를 줄이는 기술. LRO(Large Receive Offload)는 수신 측에서 패킷을 병합합니다. GSO/GRO가 소프트웨어 기반 대안으로, 가상화 환경에서도 사용 가능합니다. → 네트워크 스택

TCP/IP Stack

리눅스 커널의 네트워크 프로토콜 스택. L2(이더넷) → L3(IP) → L4(TCP/UDP) 계층으로 패킷을 처리합니다. NAPI로 수신 성능을 최적화하고, GRO/GSO로 세그멘테이션 오프로딩(Offloading)을 지원합니다. → 네트워크 스택

XDP (eXpress Data Path)

네트워크 드라이버 수준에서 eBPF 프로그램으로 패킷을 초고속 처리하는 프레임워크. 소켓 버퍼 할당 전에 동작하여 DDoS 방어, 로드 밸런싱 등에 극도로 낮은 지연을 달성합니다. → BPF/XDP

NAPI (New API)

인터럽트 기반과 폴링(Polling)을 결합한 네트워크 수신 처리 방식. 패킷이 도착하면 인터럽트를 발생시키되, 이후부터는 인터럽트를 비활성화하고 폴링으로 일괄 처리하여 고속 환경의 인터럽트 폭풍(interrupt storm)을 방지합니다. 대부분의 현대 NIC 드라이버가 지원합니다. → 네트워크 스택

GRO / GSO (세그멘테이션 오프로딩)

GRO(Generic Receive Offload)는 수신 시 여러 패킷을 하나로 합쳐 상위 스택의 처리 횟수를 줄입니다. GSO(Generic Segmentation Offload)는 송신 시 큰 패킷을 하드웨어가 처리할 크기로 늦게 분할합니다. CPU 오버헤드를 크게 줄여 고속 네트워크 성능을 향상시킵니다. → 네트워크 스택

TC / qdisc (트래픽 제어(Traffic Control))

TC(Traffic Control)는 리눅스 커널의 패킷 스케줄링·대역폭 제어 서브시스템. qdisc(Queueing Discipline)가 송신 큐의 패킷 순서를 결정합니다. HTB(계층적 토큰 버킷), CAKE, FQ(공정 큐잉) 등의 알고리즘을 지원합니다. → 네트워크 스택

디바이스 (Devices)

Bus (PCI, USB, I2C, SPI)

디바이스와 CPU 사이의 통신 경로. 각 버스는 커널에서 struct bus_type으로 표현되며, 디바이스 열거(enumeration)와 드라이버 매칭을 담당합니다. → 디바이스 드라이버

Character / Block / Network Device

커널 디바이스의 세 가지 분류. Character: 바이트 스트림 접근(터미널, 시리얼). Block: 블록 단위 접근(디스크). Network: 패킷 기반(NIC). 각각 다른 서브시스템으로 관리됩니다. → 디바이스 드라이버

Device Model (driver_register/probe)

커널의 통합 디바이스-드라이버 매칭 프레임워크. 버스가 디바이스를 발견하면 등록된 드라이버의 probe()를 호출하여 매칭합니다. driver_register()로 드라이버를, device_register()로 디바이스를 등록합니다. → 디바이스 드라이버

Device Driver (디바이스 드라이버)

하드웨어 장치를 제어하는 커널 코드. 하드웨어 추상화를 제공하여 사용자 공간에서 표준 인터페이스(open, read, write, ioctl)로 장치에 접근할 수 있게 합니다. → 디바이스 드라이버

DMA (Direct Memory Access)

CPU 개입 없이 디바이스가 직접 메모리에 읽기/쓰기하는 메커니즘. CPU 부하를 줄이고 데이터 전송 속도를 높입니다. 커널은 DMA 매핑 API(dma_map_single() 등)를 제공합니다. → 디바이스 드라이버

GPIO (General Purpose I/O)

범용 입출력(I/O) 핀. SoC의 핀을 입력(센서 읽기) 또는 출력(LED 제어)으로 설정할 수 있습니다. 커널은 gpiolib 프레임워크와 gpio descriptor API로 통합 관리합니다. Device Tree의 gpio-controller 노드로 정의됩니다. → 디바이스 드라이버

Firmware

하드웨어 디바이스에 로드되는 바이너리 코드. 커널은 request_firmware()로 /lib/firmware/에서 펌웨어를 로드하여 디바이스에 전달합니다. Wi-Fi, GPU 등 많은 장치가 펌웨어를 필요로 합니다.

IRQ (Interrupt Request)

하드웨어 디바이스가 CPU에 비동기 이벤트를 알리는 메커니즘. request_irq()로 핸들러를 등록하며, top half(즉시 처리)와 bottom half(지연 처리)로 나누어 처리합니다. → 인터럽트

IRR (Interrupt Request Register)

x86 APIC(Advanced Programmable Interrupt Controller) 내부의 256비트 레지스터. 대기 중인(pending) 인터럽트 벡터 비트를 저장합니다. CPU가 해당 인터럽트 처리를 시작하면 비트가 ISR(In-Service Register)로 이동하고, EOI(End of Interrupt) 신호를 받으면 ISR 비트가 클리어됩니다. → 인터럽트

ISR (Interrupt Service Routine)

인터럽트가 발생했을 때 실행되는 핸들러 함수. 리눅스에서는 request_irq() 또는 request_threaded_irq()로 등록합니다. ISR은 하드 IRQ 컨텍스트에서 실행되므로 sleep·블로킹 연산이 금지됩니다. 처리 시간이 긴 작업은 bottom half(softirq, tasklet, workqueue)로 미뤄야 합니다. → 인터럽트

MMIO (Memory-Mapped I/O)

디바이스 레지스터를 메모리 주소 공간에 매핑하여 일반 메모리 읽기/쓰기 명령으로 접근하는 방식. ioremap()으로 물리 주소를 가상 주소에 매핑한 뒤 readl()/writel()로 접근합니다.

Regulator Framework

전압 레귤레이터(PMIC)를 제어하는 커널 프레임워크. 디바이스 드라이버가 regulator_get()/regulator_enable()로 전원을 요청하면, 레귤레이터 드라이버가 하드웨어를 제어합니다. 전원 제약 조건과 소비자-공급자 관계를 관리합니다.

Platform Device

PCI/USB 같은 자동 열거 버스에 연결되지 않는 SoC 내장 디바이스. Device Tree 또는 ACPI로 기술하며, platform_driver로 드라이버를 등록합니다. → 디바이스 드라이버

디버깅 도구 (Debugging Tools)

debugfs

커널 디버깅 정보를 노출하는 가상 파일시스템. /sys/kernel/debug에 마운트되며, ftrace·BPF·DRM 등 서브시스템이 디버깅용 인터페이스를 제공합니다. 운영 환경에서는 마운트하지 않는 것이 보안상 권장됩니다. → 디버깅

dmesg

커널 링 버퍼의 로그 메시지를 조회하는 명령. printk()로 출력된 부팅 메시지, 드라이버 로드 정보, 오류 메시지 등을 확인합니다. dmesg -w로 실시간 모니터링, dmesg -T로 사람이 읽기 쉬운 타임스탬프를 표시합니다.

ftrace

커널 내장 함수 호출 추적(Call Trace) 프레임워크. /sys/kernel/debug/tracing을 통해 제어하며, 함수 진입·반환 시점을 기록합니다. function_graph tracer로 호출 그래프를, latency tracer로 스케줄링 지연을 분석할 수 있습니다. → ftrace

kprobes / uprobes

커널(kprobes) 또는 사용자 공간(uprobes) 코드의 임의 지점에 런타임 동적 계측 프로브(Probe)를 삽입하는 기술. 재컴파일 없이 함수 인자, 반환값, 실행 경로를 관찰할 수 있습니다. eBPF와 결합하여 강력한 동적 추적이 가능합니다. → 디버깅

perf

CPU PMU(Performance Monitoring Unit) 하드웨어 카운터를 활용한 커널/사용자 공간 성능 분석 도구. 캐시 미스, 분기 예측(Branch Prediction) 실패, CPU 사이클 등을 측정하고 플레임 그래프로 시각화할 수 있습니다. → 디버깅

lockdep

잠금 획득 순서를 추적하여 잠재적 교착 상태(deadlock)를 런타임에 감지하는 커널 검증기. 실제 교착 상태가 발생하기 전에 의존성 순환을 탐지하여 경고를 출력합니다. CONFIG_LOCKDEP으로 활성화합니다. → 디버깅

KCSAN (Kernel Concurrency Sanitizer)

컴파일러 계측 기반으로 데이터 경쟁(data race)을 런타임에 탐지하는 도구. 둘 이상의 스레드가 동일 메모리에 동시 접근하면서 하나 이상이 쓰기이고, 적절한 동기화가 없는 경우를 보고합니다. CONFIG_KCSAN으로 활성화합니다. → 디버깅

KASAN (Kernel Address Sanitizer)

힙·스택 메모리의 버퍼 오버플로(Buffer Overflow)우, use-after-free 등 메모리 접근 오류를 런타임에 탐지하는 도구. 섀도우 메모리(shadow memory)를 사용하여 각 바이트의 접근 상태를 추적합니다. CONFIG_KASAN으로 활성화합니다. → 디버깅

kdump / kexec

커널 패닉(Kernel Panic) 발생 시 메모리 상태(vmcore)를 덤프(Dump)하여 분석하는 메커니즘. kexec로 사전에 로드해 둔 캡처 커널이 패닉 발생 시 즉시 부팅되어 메모리를 파일로 저장합니다. crash 도구로 vmcore를 분석합니다. → 디버깅

Stack Trace / Backtrace

함수 호출 체인을 추적하여 현재 실행 지점까지의 경로를 보여주는 정보. 커널 패닉, WARN, BUG 발생 시 자동으로 출력됩니다. dump_stack()으로 명시적으로 출력할 수 있으며, ftrace·perf로도 수집 가능합니다.

Tracepoint

커널 소스에 정적으로 삽입된 계측 지점. TRACE_EVENT() 매크로로 정의되며 활성화 시에만 콜백을 호출합니다. kprobe보다 오버헤드가 적고 안정적입니다. /sys/kernel/debug/tracing/events에서 관리하며 perf·ftrace·eBPF에서 활용합니다. → ftrace

UBSAN (Undefined Behavior Sanitizer)

정수 오버플로(Integer Overflow)우, 배열 인덱스 초과, 정렬 오류 등 C 언어의 정의되지 않은 동작(Undefined Behavior)을 런타임에 탐지하는 도구. CONFIG_UBSAN으로 활성화하며 KASAN과 함께 사용하면 메모리 버그 탐지율이 높아집니다. → 디버깅

커널 Sanitizer 비교

ftrace 사용 예제

# ftrace로 함수 호출 추적하기
$ cd /sys/kernel/debug/tracing

# 사용 가능한 tracer 목록 확인
$ cat available_tracers
# hwlat blk mmiotrace function_graph wakeup ... nop

# function_graph tracer 활성화
$ echo function_graph > current_tracer

# 특정 함수만 추적 (예: VFS 계층)
$ echo 'vfs_read' > set_graph_function
$ echo 1 > tracing_on

# 추적 결과 확인
$ cat trace
#  2)               |  vfs_read() {
#  2)               |    rw_verify_area() {
#  2)   0.215 us    |      security_file_permission();
#  2)   0.892 us    |    }
#  2)               |    ext4_file_read_iter() { ... }
#  2) + 12.450 us   |  }

# 추적 중지
$ echo 0 > tracing_on
$ echo nop > current_tracer

인터럽트 / Bottom Half

Bottom Half

인터럽트 후반부 처리의 총칭. 하드웨어 인터럽트 핸들러(top half)가 최소한의 긴급 작업만 수행한 뒤, 나머지 처리를 softirq·tasklet·workqueue 등의 bottom half 메커니즘으로 미루어 인터럽트 비활성화 시간을 최소화합니다. → 인터럽트

Hardirq

하드웨어 인터럽트 컨텍스트. CPU가 인터럽트를 수신하면 현재 작업을 중단하고 즉시 ISR을 실행합니다. 이 컨텍스트에서는 sleep·블로킹이 금지되며 처리 시간을 최소화해야 합니다. in_irq()로 현재 컨텍스트를 확인할 수 있습니다. → 인터럽트

IPI (Inter-Processor Interrupt)

한 CPU가 다른 CPU에 보내는 인터럽트. TLB 플러시 전파, 함수 호출 요청(smp_call_function()), 스케줄러 리스케줄 통지 등에 사용됩니다. SMP 시스템의 CPU 간 협조에 필수적인 메커니즘입니다.

ksoftirqd

softirq 처리를 전담하는 per-CPU 커널 스레드. softirq가 과도하게 발생하여 인터럽트 컨텍스트에서 처리하기 어려울 때, ksoftirqd가 프로세스 컨텍스트에서 이어서 처리합니다. 네트워크 대량 수신 시 활성화되는 것을 흔히 볼 수 있습니다.

NMI (Non-Maskable Interrupt)

마스크(비활성화)할 수 없는 최고 우선순위 인터럽트. 하드웨어 오류, 워치독 타임아웃, 성능 모니터링 오버플로우 등 긴급 상황에서 발생합니다. NMI 핸들러는 거의 모든 커널 기능을 사용할 수 없으므로 극도로 제한된 코드만 실행합니다.

Softirq

하드웨어 인터럽트 후에 실행되는 지연 인터럽트 처리 메커니즘. 컴파일 시 고정된 6종(HI, TIMER, NET_TX, NET_RX, BLOCK, TASKLET)이 있습니다. 인터럽트 비활성화 없이 실행되므로 동일 CPU에서 재진입이 가능합니다. → 인터럽트

Tasklet

softirq 기반의 동적 지연 처리 단위. 동일 tasklet은 동시에 하나의 CPU에서만 실행되므로 동기화가 간단합니다. tasklet_init()/tasklet_schedule()로 사용합니다. 최근에는 workqueue 사용이 권장되며 점차 줄어드는 추세입니다.

Threaded IRQ

인터럽트 핸들러의 후반부를 전용 커널 스레드에서 실행하는 방식. request_threaded_irq()로 등록하며, 스레드 컨텍스트에서 실행되므로 sleep이 가능합니다. RT(실시간) 커널에서 인터럽트 우선순위 제어에 필수적입니다. → 인터럽트

Bottom Half 메커니즘 비교

인터럽트 핸들러 등록 코드

/* Top half + Threaded bottom half 패턴 */
static irqreturn_t my_hardirq(int irq, void *dev_id)
{
    struct my_dev *dev = dev_id;

    /* 최소한의 긴급 처리: 인터럽트 원인 확인 */
    if (!(readl(dev->regs + IRQ_STATUS) & MY_IRQ_BIT))
        return IRQ_NONE;  /* 내 인터럽트가 아님 */

    writel(MY_IRQ_BIT, dev->regs + IRQ_ACK);
    return IRQ_WAKE_THREAD;  /* bottom half로 위임 */
}

static irqreturn_t my_thread_fn(int irq, void *dev_id)
{
    /* 스레드 컨텍스트: sleep, mutex_lock 등 가능 */
    mutex_lock(&dev->lock);
    /* ... 데이터 처리 ... */
    mutex_unlock(&dev->lock);
    return IRQ_HANDLED;
}

/* 드라이버 probe에서 등록 */
request_threaded_irq(irq, my_hardirq, my_thread_fn,
    IRQF_SHARED, "my_driver", dev);

시간 / 타이머 (Time / Timer)

clockevent

주기적 또는 일회성 타이머 인터럽트를 발생시키는 하드웨어 장치의 추상화. 각 CPU에 하나의 clockevent 장치가 할당되어 스케줄러 틱, hrtimer 만료 등을 트리거합니다. LAPIC 타이머, ARM arch_timer 등이 해당합니다.

clocksource

시간 측정에 사용되는 하드웨어 카운터의 추상화. TSC(x86), HPET, ACPI PM Timer, ARM arch_timer 등이 있습니다. 커널은 가장 높은 정밀도와 안정성을 가진 clocksource를 자동 선택합니다. /sys/devices/system/clocksource에서 확인 가능합니다.

hrtimer

나노초 정밀도의 고해상도 타이머(hrtimer). 레드-블랙 트리로 관리되며 clockevent 장치를 이용해 정확한 만료 시점에 콜백을 실행합니다. CLOCK_MONOTONIC, CLOCK_REALTIME 등 다양한 시간 기준을 지원합니다. nanosleep(), timerfd 등의 기반입니다.

HZ / Tick

커널 타이머 인터럽트의 주파수(HZ)와 그 주기(tick). HZ=1000이면 1ms마다 틱 인터럽트가 발생합니다. CONFIG_HZ로 설정하며, NO_HZ(tickless) 모드에서는 유휴 시 틱을 억제하여 전력을 절약합니다.

jiffies

시스템 부팅 이후 경과한 틱 수를 저장하는 전역 카운터. seqlock으로 보호되어 안전하게 읽을 수 있습니다. jiffies_to_msecs(), msecs_to_jiffies()로 시간 단위 변환이 가능합니다. 타임아웃, 지연 시간 계산에 널리 사용됩니다.

ktime_t

나노초 단위의 커널 시간 타입. 64비트 정수로 표현되며 hrtimer, clocksource 등 고정밀 시간 관리에 사용됩니다. ktime_get()으로 현재 monotonic 시간을, ktime_get_real()로 wall clock 시간을 얻습니다.

Timer Wheel

만료 시각별로 타이머를 계층적 해시(Hash) 버킷에 배치하여 효율적으로 관리하는 구조. 정밀도가 틱 단위(ms)이며 hrtimer보다 오버헤드가 적습니다. add_timer()/mod_timer()/del_timer()로 사용하며, TCP 재전송(Retransmission) 타이머 등에 활용됩니다.

가상화 (Virtualization)

EPT / NPT

하드웨어 중첩 페이지 테이블. Intel EPT(Extended Page Tables)와 AMD NPT(Nested Page Tables)는 게스트 물리 주소를 호스트 물리 주소로 변환하는 이중 주소 변환(Address Translation)을 하드웨어에서 수행합니다. 소프트웨어 섀도 페이지 테이블 대비 성능이 크게 향상됩니다.

Hypervisor / VMM

가상 머신을 생성·관리하는 소프트웨어. Type 1(베어메탈: KVM, Xen)은 하드웨어 위에 직접 실행되고, Type 2(호스트형: VirtualBox)는 호스트 OS 위에서 실행됩니다. KVM은 리눅스 커널 자체가 하이퍼바이저(Hypervisor) 역할을 합니다.

KVM (Kernel-based Virtual Machine)

리눅스 커널에 내장된 하이퍼바이저. CPU의 하드웨어 가상화 확장(Intel VT-x, AMD-V)을 활용하여 게스트 OS를 네이티브에 가까운 성능으로 실행합니다. /dev/kvm 디바이스를 통해 QEMU 등 사용자 공간 프로그램이 VM을 관리합니다.

Live Migration

실행 중인 가상 머신을 중단 없이 다른 물리 호스트로 이전하는 기술. 메모리 페이지를 반복적으로 복사(pre-copy)하고 마지막에 짧은 다운타임 동안 CPU 상태를 전환합니다. 서버 유지보수, 부하 분산(Load Balancing)에 활용됩니다.

Paravirtualization

게스트 OS가 하이퍼바이저의 존재를 인식하고 수정된 인터페이스를 사용하는 가상화 방식. 전체 가상화보다 오버헤드가 적습니다. virtio(블록/네트워크 I/O), pv-clock(시간 동기화) 등이 대표적인 준가상화 인터페이스입니다.

QEMU

하드웨어 에뮬레이터이자 KVM의 사용자 공간 프론트엔드. 단독으로 전체 에뮬레이션을 수행하거나, KVM과 결합하여 하드웨어 가속 가상화를 제공합니다. 디바이스 에뮬레이션(네트워크, 디스크, GPU 등)을 담당합니다.

VFIO

물리 디바이스를 가상 머신에 직접 할당(passthrough)하는 프레임워크. IOMMU를 활용하여 디바이스 DMA를 안전하게 격리합니다. GPU, NIC 등 고성능 디바이스를 게스트에서 네이티브 성능으로 사용할 수 있습니다.

virtio

가상화 환경의 표준 I/O 인터페이스. 게스트와 호스트 간 공유 메모리 링(virtqueue)을 통해 I/O를 전달합니다. virtio-blk(블록), virtio-net(네트워크), virtio-fs(파일시스템) 등이 있으며, 에뮬레이션 대비 높은 성능을 제공합니다.

가상화 I/O 방식 비교

커널 자료구조 (Kernel Data Structures)

Bitmap

비트 단위로 자원을 관리하는 구조. CPU 마스크(cpumask_t), IRQ 할당, 페이지 프레임(Page Frame) 상태 추적 등에 사용됩니다. set_bit()/clear_bit()/test_bit() 원자적 연산과 find_first_bit() 등 탐색 함수를 제공합니다.

Hash Table

해시 함수 기반 O(1) 평균 탐색 구조. 커널은 체이닝 방식의 해시 테이블(Hash Table)을 널리 사용합니다. PID 검색(pid_hash), dentry 캐시(dentry_hashtable), 커넥션 트래킹 등에 활용됩니다. hash_init()/hash_add()/hash_for_each() 매크로로 사용합니다.

IDR / IDA

정수 ID를 할당·관리하는 자료구조. IDR(ID Radix tree)은 ID와 포인터의 매핑을, IDA(ID Allocator)는 순수 ID 할당만을 제공합니다. 파일 디스크립터 번호, IPC ID, 디바이스 마이너 번호 등의 할당에 사용됩니다.

kfifo

커널 링 버퍼(원형 큐) 구현. 단일 생산자/단일 소비자 패턴에서 락프리로 동작합니다. 크기는 2의 거듭제곱이어야 하며, DMA 버퍼, 로그 수집, 드라이버 데이터 전달 등에 사용됩니다. kfifo_put()/kfifo_get()으로 사용합니다.

Linked List (list_head)

커널 표준 이중 원형 연결 리스트. struct list_head를 구조체에 내장하고 container_of()로 부모를 역추적합니다. list_add(), list_del(), list_for_each_entry() 등 풍부한 매크로를 제공하며 커널 전반에서 가장 많이 사용되는 자료구조입니다.

Maple Tree

VMA 관리를 위해 도입된 B-tree 변형 자료구조 (커널 6.1+). 기존 레드-블랙 트리 + 연결 리스트 조합을 대체하여 범위 기반 탐색과 RCU 안전 순회를 효율적으로 제공합니다. mm_struct의 VMA 관리에 사용됩니다.

Radix Tree / XArray

기수(radix) 기반 연관 배열. 정수 키에서 값으로의 매핑을 효율적으로 제공합니다. 페이지 캐시가 대표적인 사용처입니다. XArray(4.20+)는 Radix Tree를 대체하는 개선된 API로, 락킹 지원과 멀티인덱스 엔트리를 제공합니다.

Red-Black Tree (rbtree)

O(log n) 삽입·삭제·탐색을 보장하는 자가 균형 이진 탐색 트리. CFS 스케줄러(vruntime 정렬), 메모리 할당(VMA 관리, 6.1 이전), hrtimer, I/O 스케줄러 등에서 핵심 자료구조로 사용됩니다. rb_insert_color()/rb_erase()로 조작합니다.

연결 리스트 사용 패턴

/* 커널 표준 이중 연결 리스트 사용 예 */
struct my_item {
    int                 data;
    struct list_head    list;  /* 리스트 노드 내장 */
};

/* 리스트 헤드 선언 */
LIST_HEAD(my_list);

/* 항목 추가 */
struct my_item *item = kmalloc(sizeof(*item), GFP_KERNEL);
item->data = 42;
list_add_tail(&item->list, &my_list);

/* 안전한 순회 (순회 중 삭제 가능) */
struct my_item *pos, *tmp;
list_for_each_entry_safe(pos, tmp, &my_list, list) {
    if (pos->data == 42) {
        list_del(&pos->list);
        kfree(pos);
    }
}

자료구조 시간 복잡도 비교

전원 관리 (Power Management)

C-State / P-State

CPU 전력 상태. C-State(C0~Cn)는 유휴 상태(Idle State)의 전력 절감 수준으로, 깊은 C-State일수록 전력이 적지만 깨어나는 데 시간이 걸립니다. P-State(P0~Pn)는 활성 상태에서의 전압·주파수 조합으로 성능과 전력의 트레이드오프를 제어합니다.

cpufreq

CPU 주파수를 동적으로 조절하는 커널 프레임워크. performance(최대 주파수), powersave(최소 주파수), schedutil(스케줄러 부하 기반) 등의 거버너 정책을 제공합니다. /sys/devices/system/cpu/cpufreq로 제어합니다.

cpuidle

CPU 유휴 상태를 관리하는 프레임워크. CPU가 실행할 태스크가 없을 때 적절한 C-State를 선택하여 진입시킵니다. menu, teo 등의 거버너가 유휴 지속 시간을 예측하여 최적의 깊이를 결정합니다.

DVFS (Dynamic Voltage-Frequency Scaling)

부하에 따라 CPU/GPU의 전압과 주파수를 동적으로 조절하여 전력 소모를 최적화하는 기술. 주파수를 낮출 때 전압도 함께 낮추어 전력을 크게 절감한다(전력 ∝ V²×f). cpufreq와 devfreq 프레임워크가 이를 구현합니다.

PM QoS (Power Management Quality of Service)

드라이버·사용자 공간에서 최소 성능 요구사항(지연시간, 처리량(Throughput))을 선언하는 프레임워크. cpuidle이 PM QoS 제약을 참조하여 지나치게 깊은 C-State 진입을 방지합니다. pm_qos_add_request()로 제약을 등록합니다.

Suspend / Hibernate

시스템 절전 모드(Suspend). Suspend(S3, Suspend-to-RAM)는 DRAM만 전원을 유지하고 나머지를 끕니다. Hibernate(S4, Suspend-to-Disk)는 메모리 전체를 디스크에 저장하고 완전히 전원을 끕니다. echo mem > /sys/power/state로 실행합니다.

Thermal Management

CPU/GPU 온도를 모니터링하고 임계치 초과 시 주파수 쓰로틀링이나 시스템 셧다운을 수행하는 커널 프레임워크. thermal_zone(온도 센서)과 cooling_device(쿨링 정책)로 구성됩니다. /sys/class/thermal에서 관리합니다.

I/O 서브시스템 (I/O Subsystem)

AIO (Asynchronous I/O)

레거시 리눅스 비동기 I/O 인터페이스. io_submit()/io_getevents()로 비동기 I/O를 수행합니다. Direct I/O에서만 진정한 비동기 동작을 하며 제약이 많아, io_uring으로 대체되는 추세입니다.

bio (Block I/O)

블록 계층의 I/O 요청 단위 구조체. 디스크 섹터 위치와 메모리 페이지의 매핑(bio_vec)을 담습니다. 파일시스템이 submit_bio()로 블록 계층에 전달하면 I/O 스케줄러를 거쳐 디바이스 드라이버에 도달합니다. → Block I/O

I/O Scheduler

블록 I/O 요청의 순서를 재배치(Relocation)하여 디스크 성능을 최적화하는 계층. mq-deadline(지연시간 보장), BFQ(대역폭 공정 분배), kyber(저지연) 등이 있습니다. none은 NVMe 등 빠른 장치에서 스케줄링 오버헤드를 제거합니다. → Block I/O

io_uring

커널 5.1에서 도입된 고성능 비동기 I/O 프레임워크. 사용자 공간과 커널이 공유하는 제출 큐(SQ)·완료 큐(CQ) 링 버퍼를 통해 시스템 콜 오버헤드를 최소화합니다. 파일 I/O, 네트워크, 타이머 등 다양한 연산을 통합 지원합니다.

NVMe (Non-Volatile Memory Express)

PCIe 버스를 통해 SSD에 직접 접근하는 고성능 스토리지 프로토콜. 최대 64K 큐×64K 엔트리의 병렬 I/O를 지원하며, SATA/SAS 대비 극도로 낮은 지연시간과 높은 IOPS를 제공합니다. 커널의 nvme 드라이버가 지원합니다.

Readahead

순차적 파일 읽기를 감지하여 아직 요청되지 않은 후속 페이지를 미리 읽어 페이지 캐시에 적재하는 프리페치 기법. readahead() 시스템 콜이나 커널 자동 감지로 동작합니다. 순차 읽기 워크로드의 I/O 지연을 크게 줄입니다.

Scatter-Gather I/O

물리적으로 비연속인 여러 메모리 버퍼를 하나의 DMA 전송으로 처리하는 기법. struct scatterlist로 버퍼 목록을 기술하며, IOMMU나 DMA 엔진이 여러 세그먼트를 연속 전송합니다. 대용량 I/O의 메모리 복사 오버헤드를 제거합니다.

IPC (프로세스 간 통신)

epoll

대규모 파일 디스크립터의 이벤트를 효율적으로 다중화(Multiplexing)하는 리눅스 고유 메커니즘. select()/poll()의 O(n) 스캔 대신 콜백 기반 O(1) 통지를 제공합니다. 고성능 서버(nginx, Node.js)의 이벤트 루프(Event Loop) 기반입니다. → IPC

eventfd

이벤트 통지용 경량 파일 디스크립터. 64비트 카운터를 통해 프로세스/스레드 간 이벤트를 전달합니다. epoll과 통합하여 사용하며, KVM의 ioeventfd·irqfd, io_uring의 이벤트 통지 등에 활용됩니다. → IPC

Message Queue

구조화된 메시지를 전달하는 IPC 메커니즘. SysV(msgget/msgsnd/msgrcv)와 POSIX(mq_open/mq_send/mq_receive) 두 가지 API가 있습니다. 메시지 우선순위와 크기 제한을 지원합니다. → IPC

Pipe

단방향 바이트 스트림 IPC. 셸의 | 연산자가 대표적인 사용 예입니다. pipe() 시스템 콜로 읽기/쓰기 파일 디스크립터 쌍을 생성합니다. 내부적으로 커널 버퍼(기본 64KB)를 사용하며, 이름 있는 파이프(named pipe, FIFO)도 지원합니다.

Shared Memory

여러 프로세스가 동일한 물리 메모리 영역을 자신의 주소 공간에 매핑하여 직접 접근하는 가장 빠른 IPC 방식. SysV(shmget/shmat)와 POSIX(shm_open/mmap) API가 있습니다. 동기화는 별도로 구현해야 합니다. → IPC

signalfd

시그널을 파일 디스크립터로 변환하여 read()·epoll로 처리할 수 있게 하는 메커니즘. 시그널 핸들러의 비동기 복잡성을 제거하고 이벤트 루프에 시그널을 통합할 수 있습니다. → IPC

timerfd

타이머 만료를 파일 디스크립터로 통지하는 메커니즘. timerfd_create()/timerfd_settime()으로 설정하며, read()·epoll과 통합하여 이벤트 루프에서 타이머를 처리할 수 있습니다. hrtimer를 기반으로 동작합니다. → IPC

Unix Domain Socket

같은 호스트 내 프로세스 간 양방향 통신을 위한 소켓. 네트워크 프로토콜 스택을 거치지 않아 TCP보다 빠릅니다. 파일 디스크립터 전달(SCM_RIGHTS), 자격 증명 전달(SCM_CREDENTIALS) 등 고유 기능을 제공합니다. → IPC

CPU 아키텍처 (CPU Architecture)

Branch Prediction

CPU가 조건 분기의 결과를 미리 예측하여 파이프라인(Pipeline)을 계속 채우는 기법. 예측 실패 시 파이프라인 플러시가 발생하여 수십 사이클의 성능 저하가 생깁니다. 커널에서 likely()/unlikely() 매크로로 컴파일러에 분기 힌트를 제공합니다.

Cache Coherency (MESI/MOESI)

멀티코어 시스템에서 각 코어의 캐시가 동일한 데이터에 대해 일관된 값을 유지하도록 보장하는 프로토콜. MESI(Modified, Exclusive, Shared, Invalid) 상태 머신이 대표적입니다. 스누핑(snooping) 또는 디렉토리 기반으로 구현됩니다. → CPU 캐시

Cache Line

CPU 캐시의 최소 전송·일관성 관리 단위. 보통 64바이트이며, 같은 캐시 라인(Cache Line) 내 데이터는 항상 함께 로드/무효화(Invalidation)됩니다. 자료구조를 캐시 라인에 정렬(____cacheline_aligned)하면 성능이 향상됩니다. → CPU 캐시

CPU Topology

CPU의 물리 계층 구조: 소켓(패키지) → 코어 → 하드웨어 스레드(SMT/Hyper-Threading). 커널 스케줄러는 토폴로지(Topology)를 인식하여 같은 코어·소켓 내 태스크를 배치하면 캐시 친화성을 높이고, 부하 분산 시 토폴로지를 고려합니다.

False Sharing

서로 다른 CPU가 독립적으로 접근하는 변수들이 동일한 캐시 라인에 위치할 때, 한쪽의 쓰기가 다른 쪽의 캐시를 무효화하여 불필요한 캐시 바운싱이 발생하는 현상. ____cacheline_aligned_in_smp로 변수를 분리하여 방지합니다. → CPU 캐시

Invalidation Queue

캐시 무효화 요청을 비동기적으로 처리하기 위한 큐. CPU가 무효화 요청을 즉시 처리하지 않고 큐에 넣어 두면 stale 데이터를 읽을 수 있습니다. rmb()/smp_rmb()로 큐를 소진하여 읽기 순서를 보장합니다.

Speculative Execution

CPU가 분기 결과가 확정되기 전에 미리 실행하는 최적화 기법. 예측이 맞으면 성능이 향상되지만, 틀리면 결과를 폐기합니다. Spectre, Meltdown 등 사이드 채널 취약점의 원인이 되었습니다. → 커널 취약점

Store Buffer

CPU 쓰기를 임시 저장하는 버퍼. 쓰기가 캐시에 반영되기 전에 저장되므로 다른 CPU에서 최신 값을 볼 수 없을 수 있습니다. wmb()/smp_wmb()로 스토어 버퍼를 비워 쓰기 순서를 보장합니다.

BPF / eBPF 세부

AF_XDP

eBPF XDP 프로그램과 연동하여 사용자 공간에서 초고속 패킷을 직접 송수신하는 소켓 패밀리. 커널 네트워크 스택을 완전히 우회하여 DPDK에 비견되는 성능을 제공합니다. UMEM 공유 메모리로 제로카피 전달이 가능합니다. → BPF/XDP

BPF Map

eBPF 프로그램이 커널 내에서 사용하는 key-value 자료구조. 해시맵, 배열, LRU, 링 버퍼, per-CPU 변형 등 다양한 타입이 있습니다. eBPF 프로그램 간 또는 프로그램과 사용자 공간 간 데이터 공유에 사용됩니다. → BPF/XDP

BPF Program Type

eBPF 프로그램의 실행 컨텍스트를 정의하는 타입. BPF_PROG_TYPE_KPROBE(함수 계측), BPF_PROG_TYPE_TRACEPOINT(정적 트레이스), BPF_PROG_TYPE_XDP(패킷 처리), BPF_PROG_TYPE_LSM(보안) 등 30가지 이상이 있습니다.

BPF Verifier

eBPF 프로그램의 안전성을 로드 시점에 정적으로 분석하는 엔진. 메모리 경계 초과, 무한 루프, 유효하지 않은 포인터 접근 등을 검증합니다. 검증을 통과한 프로그램만 커널에서 실행이 허용되어 커널 안정성을 보장합니다. → BPF/XDP

bpftool

BPF 프로그램·맵·링크를 관리하는 CLI 도구. 로드된 BPF 프로그램 목록 조회, 맵 내용 덤프, 프로그램 핀(pinning), BTF 정보 조회 등을 수행합니다. bpftool prog list, bpftool map dump 등으로 사용합니다.

BTF (BPF Type Format)

커널 데이터 구조의 타입 정보를 담는 메타데이터 형식. 구조체 레이아웃, 함수 시그니처 등을 기술하여 eBPF 프로그램이 커널 내부 구조에 안전하게 접근할 수 있게 합니다. CO-RE의 기반입니다. → BPF/XDP

CO-RE (Compile-Once-Run-Everywhere)

BTF 정보를 활용하여 eBPF 프로그램을 한 번 컴파일하면 서로 다른 커널 버전에서도 실행할 수 있게 하는 이식성 프레임워크. 구조체 필드 오프셋 차이를 로드 시점에 자동 보정합니다. libbpf가 CO-RE 재배치를 수행합니다. → BPF/XDP

libbpf

eBPF 프로그램을 로딩·관리하는 C 라이브러리. ELF 오브젝트에서 BPF 프로그램·맵을 파싱하고, verifier에 로드하며, CO-RE 재배치를 수행합니다. 커널 소스 tools/lib/bpf에 포함되어 있으며 BPF 생태계의 표준 라이브러리입니다. → BPF/XDP

eBPF 프로그램 작성 예제 (CO-RE)

/* kprobe eBPF 프로그램 — do_sys_openat2 추적 */
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_tracing.h>
#include <bpf/bpf_core_read.h>

struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 1024);
    __type(key, u32);       /* PID */
    __type(value, u64);     /* open 호출 횟수 */
} open_count SEC(".maps");

SEC("kprobe/do_sys_openat2")
int BPF_KPROBE(trace_openat2)
{
    u32 pid = bpf_get_current_pid_tgid() >> 32;
    u64 *count, init_val = 1;

    count = bpf_map_lookup_elem(&open_count, &pid);
    if (count)
        __sync_fetch_and_add(count, 1);
    else
        bpf_map_update_elem(&open_count, &pid,
            &init_val, BPF_ANY);

    return 0;
}

char LICENSE[] SEC("license") = "GPL";

커널 빌드 / 개발 (Kernel Build / Development)

checkpatch

커널 코딩 스타일(Coding Style) 준수를 검증하는 Perl 스크립트(scripts/checkpatch.pl). 패치 제출 전 필수적으로 실행하여 들여쓰기, 줄 길이, 함수 명명, 주석 스타일 등의 규칙 위반을 점검합니다. → 빌드 시스템

Cross Compilation

현재 호스트와 다른 아키텍처의 커널을 빌드하는 것. ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu-처럼 타겟 아키텍처와 크로스 컴파일(Cross Compilation)러 접두사를 지정합니다. 임베디드·ARM 개발에서 필수적입니다. → 빌드 시스템

DKMS (Dynamic Kernel Module Support)

커널 버전 업데이트 시 트리 외부(out-of-tree) 커널 모듈을 자동으로 재빌드·설치하는 프레임워크. NVIDIA 드라이버, VirtualBox 모듈 등 외부 드라이버가 커널 업데이트 후에도 자동으로 동작하도록 보장합니다.

Kbuild

GNU Make 기반의 커널 빌드 시스템. Kconfig로 생성된 .config에 따라 소스를 선택적으로 컴파일합니다. obj-y(빌트인), obj-m(모듈)로 빌드 대상을 지정하며, 의존성 추적·증분 빌드를 자동 관리합니다. → 빌드 시스템

Kernel Coding Style

리눅스 커널의 공식 코딩 규칙. 탭 8칸 들여쓰기, 80컬럼 줄 길이(권장), 함수는 소문자+밑줄(snake_case), 중괄호는 K&R 스타일 등을 규정합니다. Documentation/process/coding-style.rst에 문서화되어 있습니다.

커널 빌드 기본 명령

# 1. 설정
$ make menuconfig          # TUI 기반 설정
$ make olddefconfig        # 기존 .config 기반 기본값 채움

# 2. 빌드 (병렬 컴파일)
$ make -j$(nproc)          # 전체 커널 빌드
$ make -j$(nproc) modules  # 모듈만 빌드

# 3. 설치
$ sudo make modules_install
$ sudo make install

# 크로스 컴파일 (ARM64 타겟)
$ make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- \
    defconfig
$ make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- \
    -j$(nproc)

# 패치 스타일 검사
$ ./scripts/checkpatch.pl --strict my_patch.patch

Kconfig / Makefile 작성 패턴

# drivers/my_driver/Kconfig
config MY_DRIVER
    tristate "My awesome driver"
    depends on PCI
    select FW_LOADER
    help
      This driver supports my awesome hardware device.
      If unsure, say N.

# drivers/my_driver/Makefile
obj-$(CONFIG_MY_DRIVER) += my_driver.o
my_driver-y := core.o hw.o
my_driver-$(CONFIG_MY_DRIVER_DEBUG) += debug.o

참고 링크

커널 공식 문서

• The Linux Kernel documentation — 커널 공식 문서 포털, 서브시스템별 용어 정의 포함
• Kernel Glossary (공식) — 커널 공식 용어집: 머지 윈도우, RC, LKML 등 개발 프로세스 용어
• Core API Documentation — 커널 핵심 API 레퍼런스: 자료구조, 동기화, 메모리 관리 함수
• Driver API Documentation — 디바이스 드라이버 관련 용어와 API
• Kernel Admin Guide — 커널 파라미터, sysctl, /proc 인터페이스 용어 설명
• Networking Documentation — 네트워킹 서브시스템 용어: sk_buff, NAPI, TC, XDP 등

소스 코드 탐색 도구

• Bootlin Elixir Cross-Referencer — 커널 소스 심볼 검색, 함수/구조체 정의 추적
• Linux Kernel Driver DataBase (LKDDb) — Kconfig 옵션과 디바이스 ID 매핑 데이터베이스
• Linux man-pages project — 시스템 콜, 라이브러리 함수, /proc 파일 공식 매뉴얼
• Linux Cross Reference (LXR) — 커널 소스 크로스 레퍼런스 (식별자 검색)

학습 자료 및 튜토리얼

• KernelNewbies — Kernel Glossary — 커뮤니티 기반 커널 용어 사전 (초보자 친화적)
• KernelNewbies — FAQ — 커널 개발 자주 묻는 질문과 용어 설명
• LWN.net Kernel Index — LWN 커널 기사 주제별 색인 (서브시스템, 개념별 분류)
• LFD103 — A Beginner's Guide to Linux Kernel Development — Linux Foundation 무료 입문 강좌
• Linux Kernel Teaching Labs — 부쿠레슈티 공과대학 커널 실습 자료 (구조체, 동기화, 드라이버)
• linux-insides — 커널 내부 구조를 소스 코드 수준에서 설명하는 온라인 북

표준 및 규격

• POSIX.1-2017 (IEEE Std 1003.1) — 시스템 콜, 시그널, 프로세스 관련 용어의 공식 정의
• Intel® 64 and IA-32 Architectures SDM — x86 CPU 관련 용어 정의 (MSR, APIC, 페이징 등)
• Arm Architecture Reference Manual (ARMv8-A) — ARM64 아키텍처 용어 정의
• RFC Editor — 네트워킹 프로토콜 용어의 공식 정의 (TCP, UDP, IP, ICMP 등)
• UEFI Specifications — UEFI, ACPI 관련 용어 공식 규격

커뮤니티 및 토론

• lore.kernel.org — 커널 메일링 리스트 아카이브, 용어 유래와 기술 토론 원문
• Stack Overflow — linux-kernel 태그 — 커널 관련 Q&A, 용어 설명 포함
• ArchWiki — 리눅스 시스템 관리 용어와 설정 가이드 (실무 중심)
• Gentoo Wiki — 커널 설정, 드라이버, 파일시스템 관련 용어 상세 설명

관련 문서

용어집에서 다룬 주제를 더 깊이 학습하고 싶다면 다음 문서를 참고하세요.

• 커널 아키텍처 — 커널 전체 구조와 서브시스템 개요
• 메모리 관리 개요 — 가상 메모리, 페이지 테이블, Slab 할당자
• 프로세스 관리 — 스케줄러, task_struct, 컨텍스트 스위칭
• 동기화 기법 — Spinlock, Mutex, RCU, Seqlock
• VFS (Virtual Filesystem Switch) — inode, dentry, superblock 구조
• 네트워크 스택 — TCP/IP, sk_buff, 소켓 구조
• 디바이스 드라이버 — 드라이버 모델, DMA, IRQ 처리
• 보안 서브시스템 — LSM, SELinux, AppArmor, Seccomp
• 커널 취약점 — CVE, KASLR, exploit 완화 기법
• ftrace — 함수 추적, latency tracer, 이벤트 추적
• 디버깅 — kprobes, perf, KASAN, lockdep, kdump
• 인터럽트 — Softirq, Hardirq, Bottom Half 처리
• 컨테이너 — 네임스페이스, cgroup, 격리 기술
• 프로세스 간 통신 (IPC) — 파이프, 공유 메모리, 소켓, epoll
• CPU 캐시 — 캐시 라인, 일관성, False Sharing
• BPF/XDP — eBPF, Verifier, BPF Map, AF_XDP
• 빌드 시스템 — Kbuild, Kconfig, 크로스 컴파일
• 커널 모듈 — insmod, modprobe, DKMS
• 참고자료 — 공식 문서, 추천 도서, 표준 규격