시스템 콜(System Call) 레퍼런스 (System Call Reference)

x86_64 Linux 시스템 콜 전체 목록을 13개 카테고리로 정리합니다. 각 항목마다 syscall 번호, 이름, C 함수 시그니처, 한국어 설명을 제공하여 빠른 조회가 가능합니다. 동작 원리와 진입 경로는 시스템 콜 (System Call) 문서를 참고하세요.

개요

x86_64 Linux 커널에는 현재 약 340개 이상의 시스템 콜이 정의되어 있습니다 (arch/x86/entry/syscalls/syscall_64.tbl 기준). 아래 카테고리별 분포와 호출 규약을 참고하세요.

주요 errno 오류 코드 참조

syscall이 실패하면 커널은 -errno를 rax로 반환하고, glibc 래퍼가 errno 전역 변수에 양수 값을 설정한 뒤 -1을 반환합니다.

파일 I/O

파일 읽기/쓰기의 핵심 syscall 목록입니다. read()/write() 호출은 VFS → 페이지 캐시(Page Cache) → 파일시스템 드라이버 순으로 처리됩니다. 자세한 VFS 경로는 VFS 계층을 참고하세요.

open() / openat() 플래그 (flags 인자)

기본 파일 I/O 패턴

/* open → read → write → close 기본 패턴 */
int fd = openat(AT_FDCWD, "file.txt", O_RDONLY | O_CLOEXEC);
if (fd < 0) { perror("openat"); exit(1); }

char buf[4096];
ssize_t n;
while ((n = read(fd, buf, sizeof(buf))) > 0) {
    /* 부분 쓰기 처리: write는 요청보다 적게 쓸 수 있음 */
    ssize_t written = 0;
    while (written < n) {
        ssize_t w = write(STDOUT_FILENO, buf + written, n - written);
        if (w < 0) { perror("write"); break; }
        written += w;
    }
}
if (n < 0) perror("read");
close(fd);   /* EINTR에도 fd는 닫혀있으므로 재시도 금지 */

/* sendfile: 파일 → 소켓 zero-copy */
off_t off = 0;
sendfile(sock_fd, file_fd, &off, file_size);

/* pread/pwrite: 멀티스레드에서 안전한 위치 지정 I/O */
ssize_t r = pread64(fd, buf, 512, offset);  /* lseek 불필요 */

write() 커널 내부 경로

파일 디스크립터 관리

프로세스마다 고유한 파일 디스크립터 테이블을 가집니다. fd는 커널 내 struct file 객체에 대한 인덱스이며, 0(stdin), 1(stdout), 2(stderr)는 기본으로 할당됩니다. fork() 시 fd 테이블이 복사되고, execve() 시 O_CLOEXEC 설정된 fd는 자동으로 닫힙니다.

fcntl() 주요 명령 (cmd 인자)

디렉터리 & 파일시스템

디렉터리 조작, 링크, 마운트(Mount) 등 파일시스템 구조를 변경하는 syscall 목록입니다. 경로 기반 syscall보다 *at() 변형(openat, linkat, mkdirat 등)이 TOCTOU 경쟁 조건(Race Condition)을 방지하고 O_CLOEXEC를 원자적으로 설정할 수 있어 모던 코드에서 권장됩니다.

하드 링크 vs 심볼릭 링크 비교

mount() 주요 플래그

파일 변경 감시 (inotify)

inotify는 파일시스템 이벤트를 fd 기반으로 모니터링하는 메커니즘입니다. 파일 생성, 삭제, 수정, 이동 등을 감시하며, IDE의 자동 새로고침, 로그 모니터링, 빌드 도구의 파일 감시 등에 사용됩니다.

프로세스 관리

프로세스/스레드 생성, 실행, 종료, 대기에 사용하는 syscall 목록입니다. Linux에서 스레드도 clone()으로 생성되며 스레드 그룹(TGID)으로 묶입니다. fork()는 내부적으로 clone(SIGCHLD, ...)와 동일합니다.

clone() 주요 플래그 (flags 인자)

fork/exec 기본 패턴

/* fork → exec → wait 기본 패턴 */
pid_t pid = fork();
if (pid < 0) { perror("fork"); exit(1); }
if (pid == 0) {
    /* 자식: 새 프로그램 실행 */
    execve("/usr/bin/ls", (char*[]){"ls", "-la", NULL},
           (char*[]){"PATH=/usr/bin", NULL});
    _exit(127);  /* execve 실패 시 — exit() 아닌 _exit() 사용 */
}
/* 부모: 자식 종료 대기 */
int status;
waitpid(pid, &status, 0);
if (WIFEXITED(status))
    printf("종료 코드: %d\n", WEXITSTATUS(status));

/* 데몬 프로세스 생성 패턴 (POSIX) */
if (fork() > 0) _exit(0);  /* 부모 종료 → init 입양 */
setsid();                       /* 새 세션, 제어 터미널 분리 */
if (fork() > 0) _exit(0);  /* 세션 리더 아닌 프로세스로 */
chdir("/");                   /* 마운트 해제 방지 */
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);

메모리 관리

가상 메모리(Virtual Memory) 매핑, 보호, 조언에 사용하는 syscall 목록입니다. malloc()은 내부적으로 작은 할당에는 brk()를, 큰 할당(≥128KB)에는 mmap(MAP_ANONYMOUS)를 사용합니다.

mmap() prot / flags 인자

madvise() 힌트 (advice 인자)

mmap 페이지 폴트(Page Fault) 처리 흐름

mmap 활용 패턴

/* 파일 전체를 메모리 매핑하여 읽기 */
int fd = open("data.bin", O_RDONLY);
struct stat st;
fstat(fd, &st);
void *map = mmap(NULL, st.st_size, PROT_READ,
                  MAP_PRIVATE, fd, 0);
close(fd);  /* fd는 즉시 닫아도 매핑은 유지됨 */
madvise(map, st.st_size, MADV_SEQUENTIAL);
/* map[0] ~ map[st.st_size-1] 직접 접근 가능 */
munmap(map, st.st_size);

/* 익명 mmap: 큰 메모리 할당 (malloc 내부 방식) */
void *big = mmap(NULL, 1 << 20,  /* 1MB */
                  PROT_READ | PROT_WRITE,
                  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

/* 공유 메모리: 프로세스 간 통신 */
int mfd = memfd_create("shm", MFD_CLOEXEC);
ftruncate(mfd, 4096);
void *shared = mmap(NULL, 4096,
    PROT_READ | PROT_WRITE, MAP_SHARED, mfd, 0);
/* fork 후 자식과 공유됨, 또는 Unix socket으로 mfd 전달 */

네트워크 소켓

소켓은 파일 디스크립터로 표현되며, socket()으로 생성한 후 TCP 서버는 bind→listen→accept, 클라이언트는 connect 순서로 진행합니다. UDP는 connect 없이 sendto/recvfrom을 직접 사용합니다.

socket() domain / type 조합

setsockopt() 주요 옵션

TCP 서버 기본 패턴

/* 최소 TCP 에코 서버 */
int sfd = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
int on = 1;
setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));

struct sockaddr_in addr = {
    .sin_family = AF_INET,
    .sin_port   = htons(8080),
    .sin_addr   = { .s_addr = INADDR_ANY },
};
bind(sfd, (struct sockaddr *)&addr, sizeof(addr));
listen(sfd, 128);  /* somaxconn이 실제 상한 */

for (;;) {
    int cfd = accept4(sfd, NULL, NULL,
                      SOCK_CLOEXEC | SOCK_NONBLOCK);
    if (cfd < 0) continue;
    /* 실제 서버: epoll에 cfd 등록 후 비동기 처리 */
    char buf[4096];
    ssize_t n = recv(cfd, buf, sizeof(buf), 0);
    if (n > 0) send(cfd, buf, n, MSG_NOSIGNAL);
    close(cfd);
}

시그널

시그널은 프로세스에게 비동기적으로 이벤트를 알리는 메커니즘입니다. 시그널 전달은 커널이 프로세스를 스케줄링할 때 처리됩니다 — 즉각적인 중단이 아닙니다. SIGKILL과 SIGSTOP은 프로세스가 블록하거나 무시할 수 없습니다.

표준 시그널 참조 (x86_64)

시그널 핸들러 등록 패턴

/* 안전한 시그널 핸들러 패턴 */
static volatile sig_atomic_t got_signal = 0;

static void handler(int sig) {
    got_signal = 1;  /* sig_atomic_t만 안전하게 쓸 수 있음 */
}

struct sigaction sa = {
    .sa_handler = handler,
    .sa_flags   = SA_RESTART,  /* 중단된 syscall 자동 재시작 */
};
sigemptyset(&sa.sa_mask);
sigaction(SIGTERM, &sa, NULL);
sigaction(SIGINT,  &sa, NULL);

/* 이벤트 루프에서 시그널 처리 (signalfd 방식) */
sigset_t mask;
sigemptyset(&mask);
sigaddset(&mask, SIGTERM);
sigprocmask(SIG_BLOCK, &mask, NULL);
int sigfd = signalfd(-1, &mask, SFD_NONBLOCK | SFD_CLOEXEC);
/* sigfd를 epoll에 등록하면 이벤트 루프에서 시그널 처리 가능 */

IPC (프로세스 간 통신)

파이프, 공유 메모리, 세마포어(Semaphore), 메시지 큐, 이벤트 fd 등 IPC syscall 목록입니다. Linux에서 IPC 메커니즘은 특성에 따라 선택하고, 현대적 설계에서는 futex(잠금), Unix socket(메시지), memfd+mmap(대용량 공유 메모리)을 조합합니다.

IPC 활용 패턴

/* pipe2: 부모-자식 간 스트림 통신 */
int pfd[2];
pipe2(pfd, O_CLOEXEC);
if (fork() == 0) {
    close(pfd[0]);  /* 자식: 읽기 끝 닫기 */
    write(pfd[1], "hello", 5);
    _exit(0);
}
close(pfd[1]);  /* 부모: 쓰기 끝 닫기 */
char buf[64];
read(pfd[0], buf, sizeof(buf));

/* eventfd: 스레드/프로세스 간 이벤트 알림 */
int efd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
/* 생산자: 카운터 증가 */
uint64_t val = 1;
write(efd, &val, sizeof(val));
/* 소비자: 카운터 읽기 (읽으면 0으로 초기화) */
read(efd, &val, sizeof(val));
/* epoll에 efd 등록하면 생산자 알림을 이벤트 루프에서 처리 */

시간 & 타이머

시간 조회, 설정, 타이머 생성에 사용하는 syscall 목록입니다. clock_gettime과 gettimeofday는 vDSO(virtual Dynamic Shared Object)를 통해 커널 진입 없이 사용자 공간에서 직접 실행되므로 일반 syscall 대비 3~10배 빠릅니다. 고해상도 타이머(hrtimer)가 필요할 때는 CLOCK_MONOTONIC을 우선 사용하세요.

Clock ID 참조

보안 & 권한

UID/GID 변경, capabilities, seccomp, 네임스페이스 분리 등 보안 관련 syscall 목록입니다. Linux 보안은 DAC(소유자/그룹/others 권한), Capabilities(세분화된 권한), LSM(SELinux/AppArmor), seccomp(syscall 필터링), Namespaces(자원 격리)의 다층 구조로 이루어집니다.

주요 Linux Capabilities

Linux Namespaces 종류

Landlock 샌드박싱 패턴 (Linux 5.13+)

/* 파일시스템 접근을 /tmp 아래로만 제한 */
struct landlock_ruleset_attr attr = {
    .handled_access_fs = LANDLOCK_ACCESS_FS_READ_FILE |
                         LANDLOCK_ACCESS_FS_WRITE_FILE,
};
int rfd = landlock_create_ruleset(&attr, sizeof(attr), 0);

/* /tmp 아래만 읽기/쓰기 허용 */
int dir = open("/tmp", O_PATH | O_CLOEXEC);
struct landlock_path_beneath_attr rule = {
    .allowed_access = LANDLOCK_ACCESS_FS_READ_FILE |
                      LANDLOCK_ACCESS_FS_WRITE_FILE,
    .parent_fd = dir,
};
landlock_add_rule(rfd, LANDLOCK_RULE_PATH_BENEATH,
                  &rule, 0);
close(dir);

/* 규칙 적용 (되돌릴 수 없음!) */
prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
landlock_restrict_self(rfd, 0);
close(rfd);
/* 이후 /tmp 이외의 파일 접근 시 EACCES */

비동기 I/O & 이벤트

이벤트 다중화(Multiplexing), 비동기 I/O, io_uring 관련 syscall 목록입니다. epoll은 현대 이벤트 루프(nginx, libuv, tokio)의 핵심이며, io_uring(Linux 5.1+)은 syscall 자체를 제거하여 극한의 성능을 달성합니다.

epoll / poll / select / io_uring 비교

io_uring 주요 오퍼레이션 타입 (IORING_OP_*)

epoll 레벨 트리거(LT) vs 엣지 트리거(ET) 비교

epoll 이벤트 루프 패턴

int epfd = epoll_create1(EPOLL_CLOEXEC);

/* 서버 소켓을 epoll에 등록 */
struct epoll_event ev = {
    .events = EPOLLIN,
    .data.fd = server_fd,
};
epoll_ctl(epfd, EPOLL_CTL_ADD, server_fd, &ev);

struct epoll_event events[1024];
for (;;) {
    int nfds = epoll_wait(epfd, events, 1024, -1);
    for (int i = 0; i < nfds; i++) {
        if (events[i].data.fd == server_fd) {
            /* 새 연결 수락 후 epoll에 등록 */
            int cfd = accept4(server_fd, NULL, NULL,
                              SOCK_NONBLOCK | SOCK_CLOEXEC);
            ev.events = EPOLLIN | EPOLLET;  /* 엣지 트리거 */
            ev.data.fd = cfd;
            epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &ev);
        } else {
            /* ET 모드: EAGAIN까지 모든 데이터 읽기 필수 */
            for (;;) {
                ssize_t n = read(events[i].data.fd, buf, sizeof(buf));
                if (n <= 0) break;  /* EAGAIN 또는 EOF */
                process_data(buf, n);
            }
        }
    }
}

기타 시스템 콜

시스템 정보 조회, 리소스 제한, BPF, 커널 모듈 로딩 등 기타 syscall 목록입니다. bpf()와 perf_event_open()은 커널 내부 관찰 및 성능 분석 도구(BCC, bpftrace, perf, 시스템 모니터링)의 기반이며, prlimit64는 데몬/서버 프로세스의 리소스 튜닝에 필수입니다.

RLIMIT 리소스 종류

eBPF 프로그램 타입 (bpf() 주요 용도)

관련 문서

시스템 콜의 동작 원리와 각 서브시스템 내용을 담은 문서 목록입니다.

참고 자료

커널 공식 문서

• Syscall User Dispatch — 사용자 공간에서 시스템 콜을 선택적으로 가로채는 메커니즘을 설명합니다. Wine 등 호환 계층 구현에 활용됩니다.
• Adding a New System Call — 새로운 시스템 콜을 커널에 추가하는 절차와 설계 가이드라인을 다룹니다. 번호 할당, 호환 ABI, 테스트 방법을 포함합니다.
• Seccomp BPF (SECure COMPuting with filters) — BPF 필터를 사용하여 프로세스가 호출할 수 있는 시스템 콜을 제한하는 방법을 설명합니다.
• unshare system call — unshare() 시스템 콜로 네임스페이스를 분리하는 사용법과 clone() 플래그와의 관계를 설명합니다.
• Overview of the Linux Virtual File System — 파일 I/O 시스템 콜이 VFS 계층을 통해 처리되는 내부 구조를 설명합니다.

man 페이지 (Linux Programmer's Manual)

• syscalls(2) — Linux 시스템 콜 전체 목록과 각 콜이 도입된 커널 버전 정보를 제공합니다.
• syscall(2) — 아키텍처별 시스템 콜 호출 규약(레지스터 매핑, 반환값 처리)을 상세히 기술합니다.
• system_data_types(7) — 시스템 콜 시그니처에 사용되는 pid_t, size_t, off_t 등 데이터 타입의 정의와 크기를 설명합니다.
• intro(2) — 시스템 콜 섹션 소개로, 에러 반환 규약(errno)과 공통 에러 코드를 설명합니다.
• vdso(7) — vDSO(virtual Dynamic Shared Object)를 통해 gettimeofday, clock_gettime 등이 커널 진입 없이 실행되는 원리를 설명합니다.
• clone(2) — clone()/clone3()의 플래그 조합과 네임스페이스·cgroup 격리 옵션을 상세히 다룹니다.

아키텍처별 시스템 콜 테이블

• x86_64 syscall 테이블 — x86_64 아키텍처의 시스템 콜 번호, 이름, 진입 함수 매핑 테이블입니다.
• x86 (32비트) syscall 테이블 — i386 호환 모드의 시스템 콜 번호 매핑입니다. x86_64와 번호가 다릅니다.
• asm-generic/unistd.h — ARM64, RISC-V 등 새 아키텍처가 공유하는 제네릭 시스템 콜 번호 정의입니다.
• ARM64 compat (32비트) syscall 정의 — AArch32 호환 모드에서 사용하는 시스템 콜 번호를 정의합니다.

커널 소스 (Bootlin Elixir)

• arch/x86/entry/entry_64.S — x86_64 시스템 콜 진입점(entry_SYSCALL_64)의 어셈블리 구현입니다. SWAPGS, 스택 전환, 레지스터 저장 과정을 확인할 수 있습니다.
• fs/read_write.c — read()/write()/pread64()/pwrite64() 시스템 콜의 커널 구현입니다.
• kernel/fork.c — fork()/clone()/clone3() 시스템 콜의 핵심 구현인 copy_process() 함수를 포함합니다.
• mm/mmap.c — mmap()/munmap()/mprotect() 등 메모리 매핑 시스템 콜의 VMA 처리 구현입니다.
• net/socket.c — socket()/bind()/connect()/accept() 등 소켓 시스템 콜의 진입 함수를 포함합니다.
• kernel/signal.c — kill()/rt_sigaction()/rt_sigprocmask() 등 시그널 시스템 콜의 구현입니다.

LWN.net 기사

• Anatomy of a system call, part 1 (2014) — x86_64에서 시스템 콜이 사용자 공간에서 커널로 진입하는 전체 경로를 단계별로 분석합니다.
• Anatomy of a system call, part 2 (2014) — 시스템 콜 테이블 구성, SYSCALL_DEFINE 매크로, 호환 계층 처리를 이어서 설명합니다.
• The vDSO on arm64 (2017) — ARM64 아키텍처에서 vDSO 구현과 시스템 콜 오버헤드 절감 방식을 설명합니다.
• clone3(), fchmodat4(), and the obsession with flags (2020) — 새로운 시스템 콜 설계 시 확장 가능한 구조체 인자 방식의 장점을 논의합니다.
• An introduction to Linux kernel syscall auditing (2019) — 시스템 콜 감사(audit) 프레임워크의 동작 원리와 보안 활용을 설명합니다.

외부 참고 자료

• Chromium OS — Linux System Call Table — x86, x86_64, ARM, ARM64, MIPS 아키텍처별 시스템 콜 번호를 비교 정리한 테이블입니다.
• Linux Syscall Reference (Filippo Valsorda) — x86_64 시스템 콜 번호, 이름, 레지스터 매핑을 검색할 수 있는 인터랙티브 테이블입니다.
• The Definitive Guide to Linux System Calls — 시스템 콜의 저수준 동작 원리를 glibc 래퍼부터 커널 진입까지 상세히 설명합니다.