**시스템 콜(system call)**은 유저 프로그램이 하드웨어나 커널 메모리에 직접 접근할 수 없을 때 커널에 작업을 요청하는 진입 경로입니다. 평소 호출하는 read(), write(), ioctl() 같은 함수가 어떻게 아키텍처 명령어(svc #0, syscall)를 거쳐 커널의 가상 파일 시스템(VFS) file_operations 핸들러에 도달하고, 커널이 copy_from_user()와 copy_to_user()로 유저 공간 메모리를 안전하게 주고받는지 리눅스 매뉴얼 페이지·커널 공식 문서와 이 글의 실행 환경(x86-64 리눅스, gcc 14.2, strace 6.13)에서 직접 실행한 결과를 바탕으로 정리합니다.
핵심 요약
유저 프로그램은 보통 write()나 read() 같은 glibc 래퍼 함수를 호출하거나 syscall(2) 라이브러리 함수를 쓰며, 아키텍처별 명령어(arm64의 svc #0, x86-64의 syscall)와 지정된 레지스터를 통해 커널 모드로 전환합니다. 단순 읽기·쓰기로 다루기 어려운 특수 파일의 장치 파라미터 조작에는 32비트 명령 번호(_IO, _IOR, _IOW, _IOWR)와 메모리 포인터를 받는 ioctl()을 사용합니다. 커널에 진입한 호출은 VFS의 struct file_operations에 등록된 read, write, unlocked_ioctl, compat_ioctl 콜백으로 이어지며, 커널 코드는 유저 포인터를 직접 역참조하지 않고 copy_from_user()와 copy_to_user() 등으로 데이터를 복사합니다.
시스템 콜은 무엇이고 왜 필요합니까?
한 줄 답: 유저 프로그램은 하드웨어나 커널 메모리에 직접 접근할 수 없으므로, 정해진 진입 경로인 시스템 콜을 통해 커널에 작업을 요청합니다.
리눅스에서 유저 공간 프로그램은 보호된 권한 수준에서 실행되므로 디스크, 네트워크, 파이프, 특수 파일 같은 자원이나 커널 공간 메모리를 직접 건드릴 수 없습니다. 대신 읽기, 쓰기, 장치 제어 같은 작업이 필요할 때 커널이 열어 둔 공식 인터페이스인 시스템 콜을 호출해 커널 모드로 전환한 뒤 결과를 돌려받습니다.
glibc 래퍼 함수와 syscall(2)의 관계
syscall(2) 매뉴얼 페이지에 따르면, 일반적인 C 프로그램은 시스템 콜을 부를 때 write()나 read() 같은 glibc 래퍼 함수를 호출합니다. 이 래퍼 함수가 아키텍처 규약에 맞게 레지스터에 시스템 콜 번호와 인자들을 채우고 커널 전환 명령어를 실행합니다. 만약 C 라이브러리에 래퍼가 없거나 번호로 직접 호출하고 싶을 때는 어셈블리 인터페이스에 지정된 번호와 인자를 넘겨 시스템 콜을 호출해 주는 작은 라이브러리 함수인 syscall(2)를 쓸 수 있습니다.

CPU는 어떤 명령어와 레지스터로 커널 모드에 진입합니까?
한 줄 답: 아키텍처마다 전용 명령어와 레지스터 규약이 정해져 있으며, arm64는 svc #0과 w8, x86-64는 syscall 명령어와 eax에 시스템 콜 번호를 담아 커널로 전환합니다.
syscall(2) 매뉴얼의 “Architecture calling conventions” 절은 아키텍처마다 커널을 호출하고 인자를 전달하는 고유한 방식이 있다고 설명합니다. 첫 번째 표는 커널 모드로 전환하는 명령어, 시스템 콜 번호를 담는 레지스터, 반환값을 담는 레지스터를 정의하며, 두 번째 표는 시스템 콜 인자를 전달하는 레지스터를 정의합니다.
syscall(2) 매뉴얼의 아키텍처별 호출 규약 표
아래 표는 syscall(2) 매뉴얼 페이지에 수록된 두 표에서 arm64와 x86-64 행을 그대로 옮긴 것입니다. 이 글에서 arm64(svc #0)는 직접 실행하지 않았으며 매뉴얼 표를 기준으로만 설명합니다.
| Arch | Instruction | System call # | Return value | Error | Args |
|---|---|---|---|---|---|
| arm64 | svc #0 | w8 | x0, x1 | - | x0 x1 x2 x3 x4 x5 |
| x86-64 | syscall | eax | rax, rdx | - | rdi rsi rdx r10 r8 r9 |
x86-64 인라인 어셈블리로 직접 호출한 결과
x86-64에서는 syscall 명령어를 실행하기 전에 시스템 콜 번호를 rax(eax)에 넣고, 첫 세 인자를 rdi, rsi, rdx에 넣습니다. 이 글의 실행 환경(x86-64 리눅스, gcc 14.2, strace 6.13)에서 직접 실행한 결과를 확인하기 위해, x86-64에서 write 시스템 콜 번호인 1을 레지스터에 담아 syscall 명령어를 직접 실행하는 raw_syscall_x86_64.c를 작성했습니다.
/* x86-64 only: invoke write(2) with the syscall instruction directly */
int main(void) {
const char msg[] = "asm\n";
long ret;
__asm__ volatile ("syscall"
: "=a"(ret)
: "a"(1L), "D"(1L), "S"(msg), "d"(4L) /* rax=1 (write), rdi=fd, rsi=buf, rdx=len */
: "rcx", "r11", "memory");
return ret == 4 ? 0 : 1;
}
이 코드를 gcc -O0 -Wall -o raw_syscall_x86_64 raw_syscall_x86_64.c로 빌드하면 경고 없이 컴파일됩니다. strace -e trace=write ./raw_syscall_x86_64 > /dev/null 명령으로 실행했을 때 표준 에러(stderr)에 출력된 결과는 다음과 같습니다.
write(1, "asm\n", 4) = 4
+++ exited with 0 +++
glibc의 write() 함수를 거치지 않고 인라인 어셈블리의 syscall 명령어와 rax=1만 사용했음에도, 커널은 시스템 콜 번호와 레지스터 값만 보므로 strace에는 똑같이 write(1, "asm\n", 4) = 4로 나타납니다.
strace로 보면 glibc 래퍼와 syscall(2) 호출은 어떻게 보입니까?
한 줄 답: 커널은 시스템 콜 번호와 레지스터 값만 확인하므로, write() 래퍼와 syscall(SYS_write, ...) 모두 strace에서 동일한 write 시스템 콜로 기록됩니다.
일반적인 코드에서 쓰는 glibc 래퍼 함수 write()와 범용 syscall(2) 함수가 실제로 어떤 시스템 콜을 발생시키는지 비교해 볼 수 있습니다. strace의 기본적인 사용법은 strace, 프로세스가 어떤 시스템 콜을 내는지 보는 법 글에서 다룹니다.
hello_write.c 실행과 strace 출력 비교
아래 hello_write.c는 첫 줄에서 glibc 래퍼 write()를 호출하고, 둘째 줄에서 syscall(SYS_write, ...)를 호출합니다.
#include <unistd.h>
#include <sys/syscall.h>
int main(void) {
write(1, "hello\n", 6); /* glibc wrapper */
syscall(SYS_write, 1, "raw\n", 4); /* generic syscall(2) */
return 0;
}
이 글의 실행 환경(x86-64 리눅스, gcc 14.2, strace 6.13)에서 gcc -O0 -Wall -o hello_write hello_write.c로 경고 없이 빌드한 뒤, 먼저 ./hello_write를 실행한 출력은 다음과 같습니다.
hello
raw
이어서 strace -e trace=write ./hello_write > /dev/null을 실행했을 때 표준 에러(stderr)에 출력된 결과는 다음과 같습니다.
write(1, "hello\n", 6) = 6
write(1, "raw\n", 4) = 4
+++ exited with 0 +++
유저 공간에서는 write() 래퍼와 syscall(SYS_write, ...)라는 서로 다른 C 함수를 호출했지만, 둘 다 커널로 넘어갈 때는 동일한 시스템 콜 번호와 레지스터 규약을 따르므로 strace에는 똑같은 write 시스템 콜 두 번으로 기록됩니다.
read와 write만으로 부족할 때 ioctl은 어떻게 동작합니까?
한 줄 답: ioctl()은 열린 파일 디스크립터와 32비트 명령 번호, 메모리 포인터를 전달해 특수 파일의 장치 파라미터를 다루거나 상태 값을 주고받습니다.
바이트 스트림을 읽고 쓰는 read()와 write()만으로는 파일이나 장치의 세부 동작 방식을 설정하거나 버퍼에 쌓인 데이터 크기 같은 부가 정보를 조회하기 어렵습니다. ioctl(2) 매뉴얼 페이지에 따르면, ioctl() 시스템 콜은 특수 파일의 기반 장치 파라미터를 조작합니다. 첫 번째 인자인 fd는 열린 파일 디스크립터여야 하고, 두 번째 인자는 장치에 따라 정의된 동작 코드(명령 번호)이며, 세 번째 인자는 메모리를 가리키는 타입 없는 포인터입니다.
ioctl 명령 번호 구조와 _IO·_IOR·_IOW·_IOWR 매크로
ioctl(2) 매뉴얼과 리눅스 커널 문서(ioctl based interfaces)에 따르면, ioctl 시스템 콜의 두 번째 인자로 전달되는 명령 번호는 어떤 32비트 숫자든 될 수 있지만, 데이터 전송 방향(in/out), 인자 크기, 8비트 타입, 8비트 일련번호(serial number)를 함께 인코딩하는 <asm/ioctl.h>의 매크로로 정의하는 것이 권장됩니다.
_IO: 인자가 없거나 단순 정수 값을 전달할 때 사용합니다._IOW: 유저 공간에서 커널 안으로 넣는 데이터를 가리키는 포인터를 전달할 때 사용합니다._IOR: 커널에서 유저 공간 밖으로 꺼내는 데이터를 가리키는 포인터를 전달할 때 사용합니다._IOWR: 커널 안으로 데이터를 넣고 결과를 다시 꺼내는 양방향 포인터를 전달할 때 사용합니다.
파이프 버퍼의 대기 바이트 수를 조회하는 FIONREAD 예제
아래 fionread_pipe.c는 파이프를 만든 뒤 5바이트("abcde")를 써 넣고, 읽기 끝 파일 디스크립터에 FIONREAD 명령으로 ioctl()을 호출해 현재 파이프에서 읽기를 기다리는 바이트 수를 변수 n의 주소(&n)로 받아 옵니다.
#include <stdio.h>
#include <unistd.h>
#include <sys/ioctl.h>
int main(void) {
int fds[2], n = 0;
pipe(fds);
write(fds[1], "abcde", 5);
ioctl(fds[0], FIONREAD, &n); /* bytes waiting in the pipe */
printf("FIONREAD = %d\n", n);
return 0;
}
gcc -O0 -Wall -o fionread_pipe fionread_pipe.c로 경고 없이 빌드한 뒤 ./fionread_pipe를 실행한 출력은 다음과 같습니다.
FIONREAD = 5
같은 실행 파일을 strace -e trace=pipe,pipe2,write,ioctl ./fionread_pipe > /dev/null로 추적했을 때 표준 에러(stderr) 출력은 다음과 같습니다.
pipe2([3, 4], 0) = 0
write(4, "abcde", 5) = 5
ioctl(3, FIONREAD, [5]) = 0
ioctl(1, TCGETS, 0x7fff35244c60) = -1 ENOTTY (Inappropriate ioctl for device)
write(1, "FIONREAD = 5\n", 13) = 13
+++ exited with 0 +++
출력에서 ioctl(3, FIONREAD, [5]) = 0은 파이프에 써 넣은 5바이트가 대기 중임을 뜻하며, 대괄호로 표시된 [5]는 커널이 유저 프로그램이 넘긴 포인터(&n)에 써서 돌려준 값입니다. 바로 아래의 ioctl(1, TCGETS, ...) = -1 ENOTTY 줄은 표준 출력이 /dev/null로 리다이렉션된 상태에서 C 표준 입출력(stdio) 라이브러리가 표준 출력이 터미널인지 확인하려고 호출한 것입니다.
커널에 들어온 시스템 콜은 어떤 경로로 드라이버 함수에 도달합니까?
한 줄 답: 가상 파일 시스템(VFS)이 파일 디스크립터에 연결된 struct file_operations 테이블을 참조해 read, write, unlocked_ioctl, compat_ioctl 핸들러를 호출합니다.
유저 프로그램이 파일 디스크립터를 넘겨 read(), write(), ioctl()을 호출하면, 커널은 먼저 가상 파일 시스템(VFS) 계층에서 해당 열린 파일에 연결된 함수 포인터 테이블인 struct file_operations를 찾습니다. 이 글에서는 커널 모듈을 직접 빌드하거나 실행하지 않았으며, 커널 공식 문서(Overview of the Linux Virtual File System)를 기준으로 동작 경로를 설명합니다.
struct file_operations의 주요 콜백 역할
리눅스 커널 VFS 문서에 정리된 struct file_operations의 관련 멤버 역할은 다음과 같습니다.
read:read(2)및 관련 시스템 콜에 의해 호출됩니다.write:write(2)및 관련 시스템 콜에 의해 호출됩니다.unlocked_ioctl:ioctl(2)시스템 콜에 의해 호출됩니다.compat_ioctl: 64비트 커널에서 32비트 시스템 콜이 사용될 때ioctl(2)시스템 콜에 의해 호출됩니다.
드라이버 내부에서 데이터가 준비될 때까지 대기하는 흐름
VFS를 통해 드라이버의 read 경로로 들어왔을 때 아직 읽을 데이터가 준비되지 않아 호출 프로세스가 기다려야 하는 상황과 대기 방식은 「블로킹/논블로킹과 싱크/어싱크는 같은 말일까? wait queue, O_NONBLOCK, epoll, io_uring」 글에서 이어서 다룹니다.
커널은 왜 유저 공간 포인터를 직접 역참조하지 않고 copy_from_user를 사용합니까?
한 줄 답: 유저 공간 포인터는 절대 그대로 역참조해서는 안 되며, 암묵적으로 잠들 수 있으므로 유저 컨텍스트 안에서 copy_from_user()와 copy_to_user() 등의 루틴으로 데이터를 복사해야 합니다.
write()나 ioctl()은 유저 공간 버퍼나 변수의 포인터를 커널에 전달합니다. 리눅스 커널 문서(Unreliable Guide To Hacking The Linux Kernel)의 copy_to_user() / copy_from_user() / get_user() / put_user() 절(include/linux/uaccess.h, [SLEEPS] 표시)은 유저 공간으로 향하는 포인터를 절대 단순 역참조해서는 안 되며 반드시 이 루틴들을 사용해 데이터를 복사해야 한다고 명시합니다. 이 부분 역시 커널 모듈을 실행하지 않고 커널 문서를 바탕으로 설명합니다.
copy_from_user·copy_to_user와 get_user·put_user의 반환값 규약
커널 해킹 가이드 문서에 정리된 함수별 동작과 반환값은 다음과 같습니다.
get_user()/put_user(): 단일 값을 유저 공간에서 읽거나 쓸 때 사용하며, 실패 시-EFAULT를 반환하고 성공 시0을 반환합니다.copy_from_user()/copy_to_user(): 임의 크기의 데이터를 유저 공간과 커널 공간 사이에서 복사하며, 복사하지 못한 데이터양(바이트 수)을 반환합니다. 즉, 반환값0이 여전히 성공을 뜻합니다.
유저 컨텍스트와 슬립 가능성 주의점
커널 해킹 가이드는 이 함수들이 암묵적으로 잠들(sleep) 수 있으므로 절대 유저 컨텍스트 바깥에서 호출해서는 안 된다고 경고합니다. 따라서 잠들 수 있는 함수라 스핀락을 잡은 구간 같은 곳에서는 조심해야 하며, 스핀락과 뮤텍스의 차이는 스핀락과 뮤텍스 비교 글에서 확인할 수 있습니다.

자주 묻는 질문은 무엇입니까?
한 줄 답: 시스템 콜 호출 방식의 차이, 유저 포인터 직접 역참조 금지 이유, strace의 ioctl 출력 읽는 법을 정리했습니다.
glibc의 write()와 syscall(SYS_write, ...)는 커널 입장에서 차이가 있습니까?
차이가 없습니다. 커널은 시스템 콜 번호와 레지스터에 담긴 인자만 확인하므로, `hello_write.c`와 `raw_syscall_x86_64.c`의 `strace` 결과에서 보듯 glibc의 `write()` 래퍼, `syscall(SYS_write, ...)`, 인라인 어셈블리의 `syscall` 명령어(`rax=1`)는 모두 동일한 `write` 시스템 콜로 처리됩니다.커널 코드에서 유저 포인터를 그냥 역참조하면 왜 안 됩니까?
리눅스 커널 해킹 가이드(`include/linux/uaccess.h`)에 명시된 것처럼 유저 공간 포인터는 단순 역참조해서는 안 되며, 암묵적으로 잠들(sleep) 수 있는 `copy_from_user()`, `copy_to_user()`, `get_user()`, `put_user()` 루틴을 통해 유저 컨텍스트 안에서만 복사해야 합니다. 이때 `copy_from_user()`와 `copy_to_user()`는 복사하지 못한 바이트 수를 반환하므로 `0`이 성공을 의미합니다.strace 출력의 ioctl(3, FIONREAD, [5])에서 대괄호 안의 5는 무엇을 뜻합니까?
유저 프로그램이 세 번째 인자로 넘긴 포인터(`&n`)가 가리키는 메모리에 커널이 써서 돌려준 값입니다. 파이프에 먼저 `"abcde"` 5바이트를 기록했기 때문에 `FIONREAD` 조회 결과로 `5`가 기록된 것을 `strace`가 `[5]`로 보여 줍니다.함께 보면 좋은 글은 무엇입니까?
한 줄 답: 시스템 콜 추적 도구 사용법, 커널 동기화 기초, 블로킹 입출력 흐름을 이어서 살펴볼 수 있는 글 목록입니다.
- strace, 프로세스가 어떤 시스템 콜을 내는지 보는 법
- 스핀락과 뮤텍스 비교
- 「블로킹/논블로킹과 싱크/어싱크는 같은 말일까? wait queue, O_NONBLOCK, epoll, io_uring」
출처는 어디입니까?
한 줄 답: 이 글에서 인용한 리눅스 매뉴얼 페이지와 커널 공식 문서 목록입니다.
- syscall(2) — Linux manual page (확인 2026-11-04)
- ioctl(2) — Linux manual page (확인 2026-11-04)
- Linux kernel docs: ioctl based interfaces (확인 2026-11-04)
- Linux kernel docs: Overview of the Linux Virtual File System (확인 2026-11-04)
- Linux kernel docs: Unreliable Guide To Hacking The Linux Kernel (확인 2026-11-04)