memfd (Memory File Descriptors) 심화

memfd_create()는 파일 시스템에 존재하지 않는 익명 메모리 파일을 생성하는 리눅스 시스콜입니다. tmpfs 기반의 이 메모리 파일은 mmap(), read()/write(), ftruncate() 등 일반 파일 연산을 모두 지원하면서도 디스크에 흔적을 남기지 않습니다. File Sealing을 통해 공유 메모리의 불변성을 보장하고, SCM_RIGHTS를 통해 프로세스 간 안전한 메모리 교환이 가능합니다. 이 문서에서는 커널 내부 구현부터 보안 고려사항, Wayland/D-Bus 활용, memfd_secret()까지 전 영역을 다룹니다.

memfd 개요

파일 시스템 없는 메모리 파일

전통적으로 리눅스에서 프로세스 간 공유 메모리를 만들려면 shm_open()(POSIX 공유 메모리), shmget()(System V 공유 메모리), 또는 /tmp에 파일을 만들어 mmap()하는 방법을 사용했습니다. 그러나 이들은 모두 파일 시스템에 이름이 남거나, 수명 관리가 복잡하거나, 보안 문제(예: /dev/shm에 누구나 접근 가능)가 있었습니다.

memfd_create()는 Linux 3.17(2014)에 도입된 시스콜로, 이 모든 문제를 해결합니다. 이 시스콜이 반환하는 파일 디스크립터는 tmpfs(shmem) 위에 존재하지만 어떤 디렉터리에도 링크되지 않습니다. 마지막 참조가 닫히면 커널이 자동으로 메모리를 회수합니다.

기존 공유 메모리 방식과의 비교

memfd_create 시그니처

#include <sys/mman.h>

int memfd_create(const char *name, unsigned int flags);

/* 반환값: 성공 시 파일 디스크립터, 실패 시 -1 (errno 설정)
 * name: /proc/self/fd/N에 표시되는 디버깅용 이름 (경로 아님)
 * flags: MFD_CLOEXEC | MFD_ALLOW_SEALING | MFD_HUGETLB | MFD_NOEXEC_SEAL 등 */

memfd_create 시스콜 아키텍처

memfd_create()의 커널 내부 호출 흐름은 다음과 같습니다. 사용자 공간에서 시스콜을 호출하면, 커널은 tmpfs(shmem)에 익명 inode를 만들고, 이를 위한 struct file을 할당한 뒤 파일 디스크립터 번호를 반환합니다.

커널 소스: __memfd_create 핵심 경로

/* mm/memfd.c - Linux 6.x */
SYSCALL_DEFINE2(memfd_create,
    const char __user *, uname,
    unsigned int, flags)
{
    struct file *file;
    int fd, error;
    char *name;
    unsigned int *file_seals;

    /* 1. 플래그 유효성 검사 */
    if (flags & ~(MFD_CLOEXEC | MFD_ALLOW_SEALING | MFD_HUGETLB |
                  MFD_NOEXEC_SEAL | MFD_EXEC))
        return -EINVAL;

    /* 2. 사용자 공간에서 이름 복사 */
    name = strndup_user(uname, MFD_NAME_MAX_LEN + 1);

    /* 3. tmpfs(shmem)에 익명 파일 생성 */
    if (flags & MFD_HUGETLB)
        file = hugetlb_file_setup(name, 0, ...);
    else
        file = shmem_file_setup(name, 0, VM_NORESERVE);

    /* 4. sealing 초기 상태 설정 */
    if (flags & MFD_ALLOW_SEALING)
        file_seals = &(SHMEM_I(file_inode(file)))->seals;

    /* 5. noexec 처리 */
    if (flags & MFD_NOEXEC_SEAL)
        file->f_mode &= ~FMODE_EXEC;

    /* 6. fd 할당 및 설치 */
    fd = get_unused_fd_flags(
        (flags & MFD_CLOEXEC) ? O_CLOEXEC : 0);
    fd_install(fd, file);

    return fd;
}

memfd 내부 구현 (tmpfs 기반)

memfd의 배후 저장소는 tmpfs(shmem)입니다. memfd로 생성된 파일은 커널 내부의 tmpfs 인스턴스에 inode가 할당되지만, 어떤 디렉터리 엔트리(dentry)에도 연결되지 않습니다. 이러한 "연결 해제된(unlinked)" 상태가 memfd의 핵심 특성입니다.

핵심 커널 자료구조 관계

/* include/linux/shmem_fs.h */
struct shmem_inode_info {
    spinlock_t          lock;
    unsigned int        seals;       /* File Sealing 비트마스크 */
    unsigned long       flags;
    unsigned long       alloced;     /* 할당된 페이지 수 */
    unsigned long       swapped;     /* swap된 페이지 수 */
    pgoff_t             fallocend;   /* fallocate 끝 오프셋 */
    struct shared_policy policy;     /* NUMA 정책 */
    struct simple_xattrs xattrs;
    struct inode        vfs_inode;   /* 내장 VFS inode */
};

/* container_of 매크로로 vfs_inode에서 shmem_inode_info 접근 */
#define SHMEM_I(inode) \
    container_of(inode, struct shmem_inode_info, vfs_inode)

shmem_file_operations

/* mm/shmem.c */
static const struct file_operations shmem_file_operations = {
    .mmap           = shmem_mmap,
    .get_unmapped_area = shmem_get_unmapped_area,
    .llseek         = shmem_file_llseek,
    .read_iter      = shmem_file_read_iter,
    .write_iter     = generic_file_write_iter,
    .fsync          = noop_fsync,          /* 디스크 없으므로 no-op */
    .splice_read    = shmem_file_splice_read,
    .splice_write   = iter_file_splice_write,
    .fallocate      = shmem_fallocate,
};

MFD_CLOEXEC, MFD_ALLOW_SEALING 플래그

memfd_create()의 flags 인자로 전달할 수 있는 플래그들과 각각의 의미를 정리합니다.

플래그 사용 예시

/* 가장 일반적인 조합: close-on-exec + sealing 허용 */
int fd = memfd_create("shared-buf",
    MFD_CLOEXEC | MFD_ALLOW_SEALING);

/* 보안 강화: 실행 불가 + sealing */
int fd_safe = memfd_create("safe-buf",
    MFD_CLOEXEC | MFD_ALLOW_SEALING | MFD_NOEXEC_SEAL);

/* 2MB 휴즈페이지 기반 대용량 버퍼 */
int fd_huge = memfd_create("huge-buf",
    MFD_CLOEXEC | MFD_HUGETLB | MFD_HUGE_2MB);

File Sealing 메커니즘

File Sealing은 memfd의 가장 혁신적인 기능입니다. 일반적으로 공유 메모리를 사용할 때 "생산자가 데이터를 쓴 후 소비자가 읽기 전에 크기를 줄이면 어떡하지?"라는 TOCTOU(Time of Check, Time of Use) 문제가 발생합니다. Seal은 이러한 변경을 커널 수준에서 영구적으로 금지합니다.

Seal 적용 및 확인 API

#include <fcntl.h>
#include <sys/mman.h>

int fd = memfd_create("sealed", MFD_CLOEXEC | MFD_ALLOW_SEALING);
ftruncate(fd, 4096);

/* 데이터 기록 */
write(fd, "Hello, memfd!", 13);

/* Seal 적용: 쓰기 + 크기 변경 금지 */
fcntl(fd, F_ADD_SEALS,
    F_SEAL_WRITE | F_SEAL_SHRINK | F_SEAL_GROW);

/* 현재 seal 상태 확인 */
int seals = fcntl(fd, F_GET_SEALS);
if (seals & F_SEAL_WRITE)
    printf("쓰기 봉인됨\n");

/* 이후 write()는 -EPERM 반환 */
ssize_t ret = write(fd, "fail", 4);
/* ret == -1, errno == EPERM */

memfd와 프로세스 간 공유

memfd의 핵심 사용 사례는 프로세스 간 메모리 공유입니다. 파일 시스템에 이름이 없으므로, fd를 전달하는 방법은 크게 세 가지입니다:

1. SCM_RIGHTS: Unix 도메인 소켓의 ancillary data로 fd 전달 (가장 일반적)
2. pidfd_getfd(): 대상 프로세스의 fd를 직접 복제 (Linux 5.6+)
3. fork(): 자식 프로세스가 부모의 fd를 상속

SCM_RIGHTS를 이용한 fd 전달 (생산자)

static void send_fd(int sock, int fd)
{
    struct msghdr msg = {0};
    struct cmsghdr *cmsg;
    char buf[CMSG_SPACE(sizeof(int))];
    struct iovec iov = { .iov_base = "x", .iov_len = 1 };

    msg.msg_iov = &iov;
    msg.msg_iovlen = 1;
    msg.msg_control = buf;
    msg.msg_controllen = sizeof(buf);

    cmsg = CMSG_FIRSTHDR(&msg);
    cmsg->cmsg_level = SOL_SOCKET;
    cmsg->cmsg_type  = SCM_RIGHTS;
    cmsg->cmsg_len   = CMSG_LEN(sizeof(int));
    memcpy(CMSG_DATA(cmsg), &fd, sizeof(int));

    sendmsg(sock, &msg, 0);
}

pidfd_getfd()를 이용한 fd 복제 (Linux 5.6+)

/* 대상 프로세스의 fd를 직접 복제 (ptrace 권한 필요) */
int pidfd = pidfd_open(target_pid, 0);
int stolen_fd = pidfd_getfd(pidfd, target_fd, 0);
/* stolen_fd는 현재 프로세스의 새 fd로,
 * target_pid 프로세스의 target_fd와 같은 파일을 참조 */

/* seal 상태 확인 */
int seals = fcntl(stolen_fd, F_GET_SEALS);
printf("seals: 0x%x\n", seals);

memfd와 mmap 연동

memfd는 mmap()과 함께 사용할 때 가장 큰 효과를 발휘합니다. read()/write() 시스콜 오버헤드 없이 메모리를 직접 접근할 수 있으며, 여러 프로세스가 동일한 물리 페이지를 공유합니다.

mmap 활용 패턴

/* memfd를 mmap으로 매핑하여 제로카피 IPC */
int fd = memfd_create("ipc-region",
    MFD_CLOEXEC | MFD_ALLOW_SEALING);
ftruncate(fd, 4096 * 16);  /* 64KB */

/* 쓰기 가능 매핑 (생산자) */
void *ptr = mmap(NULL, 4096 * 16,
    PROT_READ | PROT_WRITE,
    MAP_SHARED, fd, 0);

/* 데이터 기록 */
memcpy(ptr, data, data_len);

/* 매핑 해제 후 seal 적용 */
munmap(ptr, 4096 * 16);
fcntl(fd, F_ADD_SEALS,
    F_SEAL_WRITE | F_SEAL_SHRINK | F_SEAL_GROW);

/* fd를 소비자에게 전달 (SCM_RIGHTS)
 * 소비자는 PROT_READ로만 mmap하여 안전하게 접근 */

memfd_secret (비밀 메모리)

memfd_secret()는 Linux 5.14에 도입된 시스콜로, 커널조차 접근할 수 없는 비밀 메모리 영역을 생성합니다. 암호화 키, 비밀번호 등 민감한 데이터를 보호하는 데 사용됩니다.

memfd_secret vs memfd_create 차이

memfd_secret 사용 예시

#include <sys/mman.h>
#include <sys/syscall.h>
#include <unistd.h>
#include <string.h>

/* memfd_secret()은 glibc 래퍼가 없을 수 있음 */
static int memfd_secret_wrapper(unsigned int flags)
{
    return syscall(SYS_memfd_secret, flags);
}

int main(void)
{
    int fd = memfd_secret_wrapper(0);
    if (fd < 0) {
        perror("memfd_secret");
        return 1;
    }

    /* 크기 설정 */
    ftruncate(fd, 4096);

    /* mmap으로만 접근 가능 (read/write 시스콜 불가) */
    char *secret = mmap(NULL, 4096,
        PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

    /* 비밀 데이터 저장 */
    memcpy(secret, "super-secret-key-1234", 21);

    /* ... 비밀 데이터 사용 ... */

    /* 사용 후 명시적으로 제로화 */
    explicit_bzero(secret, 4096);
    munmap(secret, 4096);
    close(fd);

    return 0;
}

Wayland / D-Bus에서의 memfd 활용

memfd는 현대 리눅스 데스크탑 스택의 핵심 인프라입니다. Wayland 컴포지터와 클라이언트 간의 그래픽 버퍼 공유, D-Bus의 대용량 메시지 전달에 memfd가 사용됩니다.

Wayland에서의 wl_shm + memfd

Wayland 프로토콜에서 클라이언트(앱)는 wl_shm 인터페이스를 통해 컴포지터와 그래픽 버퍼를 공유합니다. 전통적으로 /dev/shm에 파일을 만들었으나, 현대 구현체(wlroots, Mutter 등)는 memfd를 선호합니다.

/* Wayland 클라이언트: wl_shm 버퍼 생성 */
int fd = memfd_create("wl_shm", MFD_CLOEXEC | MFD_ALLOW_SEALING);
int stride = width * 4;  /* ARGB8888 */
int size = stride * height;

ftruncate(fd, size);

/* 픽셀 데이터를 직접 기록 */
void *pixels = mmap(NULL, size,
    PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
/* ... 렌더링 ... */

/* wl_shm_pool 생성 (fd가 컴포지터로 전달됨) */
struct wl_shm_pool *pool =
    wl_shm_create_pool(shm, fd, size);
struct wl_buffer *buffer =
    wl_shm_pool_create_buffer(pool, 0,
        width, height, stride, WL_SHM_FORMAT_ARGB8888);

D-Bus memfd 전송

D-Bus (kdbus, bus1 제안 포함)에서 대용량 메시지를 전달할 때 memfd를 사용하면 소켓 버퍼 복사를 피하고 제로카피에 가까운 성능을 달성할 수 있습니다. DBUS_TYPE_UNIX_FD를 통해 memfd의 파일 디스크립터를 전달합니다.

/* sd-bus를 이용한 memfd 전달 예시 (systemd) */
int fd = memfd_create("dbus-payload",
    MFD_CLOEXEC | MFD_ALLOW_SEALING);
ftruncate(fd, payload_size);
write(fd, payload_data, payload_size);

/* seal 적용: 수신 측에서 안전하게 사용 가능 */
fcntl(fd, F_ADD_SEALS,
    F_SEAL_SHRINK | F_SEAL_GROW | F_SEAL_WRITE | F_SEAL_SEAL);

/* D-Bus 메시지에 fd 첨부 */
sd_bus_message_append(msg, "h", fd);

보안 고려사항

memfd는 강력한 기능이지만, 악용될 수 있는 공격 벡터가 존재합니다. 특히 memfd를 통한 파일리스(fileless) 코드 실행이 주요 보안 위협입니다.

memfd + exec 공격 벡터

공격자가 시스템에 임의 코드를 실행하고자 할 때, 디스크에 파일을 쓰지 않고 memfd를 이용하여 ELF 바이너리를 메모리에 올린 뒤 execve()로 실행할 수 있습니다. 이 기법은 /proc/self/fd/N 경로를 통해 가능합니다.

/* 경고: 이 패턴은 악성코드에서 사용되는 기법입니다
 * 보안 이해를 위한 목적으로만 제시합니다 */

/* 1. memfd 생성 */
int fd = memfd_create("", MFD_CLOEXEC);

/* 2. ELF 바이너리 기록 */
write(fd, elf_payload, elf_size);

/* 3. /proc/self/fd/N을 통해 실행 */
char path[64];
snprintf(path, sizeof(path), "/proc/self/fd/%d", fd);
execve(path, argv, envp);
/* 디스크에 어떤 파일도 생성되지 않음 (파일리스 공격) */

MFD_NOEXEC_SEAL 방어 (Linux 6.3+)

이 공격을 방어하기 위해 Linux 6.3에서 MFD_NOEXEC_SEAL 플래그와 vm.memfd_noexec sysctl이 도입되었습니다.

# 시스템 전체에서 memfd 실행 차단 (보안 강화)
sysctl -w vm.memfd_noexec=2

# 영구 설정
echo "vm.memfd_noexec = 2" >> /etc/sysctl.d/99-memfd-noexec.conf

커널 설정과 sysctl

커널 빌드 설정 (Kconfig)

sysctl 매개변수

# memfd 실행 권한 정책 확인/설정
cat /proc/sys/vm/memfd_noexec
sysctl vm.memfd_noexec

# tmpfs 전체 크기 제한 (memfd도 이 제한에 포함)
mount | grep tmpfs
# tmpfs on /dev/shm type tmpfs (rw,nosuid,nodev,size=8G)

# memfd의 현재 사용량 확인 
cat /proc/meminfo | grep Shmem
# Shmem: 총 shmem/tmpfs 사용량 (memfd 포함)

/proc/<pid>/fdinfo 확인

# memfd의 seal 상태 확인
cat /proc/self/fdinfo/3
# pos:    0
# flags:  02
# mnt_id: 26
# ino:    12345
# seals:  0xf    (모든 seal 적용됨)

# memfd 목록 확인
ls -la /proc/self/fd/ | grep memfd
# lrwx------ 1 user user 64 ... 3 -> /memfd:buf (deleted)

성능 특성

memfd의 성능은 tmpfs(shmem)의 성능 특성을 그대로 따릅니다. 페이지 할당은 Buddy Allocator를 통해 이루어지며, swap 가능합니다.

성능 최적화 팁

벤치마크 코드

#include <sys/mman.h>
#include <time.h>
#include <stdio.h>
#include <unistd.h>

static double bench_memfd_mmap(size_t size, int iterations)
{
    struct timespec start, end;
    clock_gettime(CLOCK_MONOTONIC, &start);

    for (int i = 0; i < iterations; i++) {
        int fd = memfd_create("bench", MFD_CLOEXEC);
        ftruncate(fd, size);

        void *p = mmap(NULL, size,
            PROT_READ | PROT_WRITE,
            MAP_SHARED, fd, 0);
        ((volatile char *)p)[0] = 1;  /* 페이지 폴트 유발 */
        munmap(p, size);
        close(fd);
    }

    clock_gettime(CLOCK_MONOTONIC, &end);
    double elapsed = (end.tv_sec - start.tv_sec)
        + (end.tv_nsec - start.tv_nsec) / 1e9;
    return elapsed / iterations * 1e6; /* 마이크로초 */
}

실전 사용 사례

1. IPC: 구조화된 데이터 공유

/* 헤더 + 가변 길이 데이터를 memfd로 공유 */
struct shared_header {
    uint32_t magic;
    uint32_t version;
    uint64_t data_offset;
    uint64_t data_len;
};

int fd = memfd_create("structured-ipc",
    MFD_CLOEXEC | MFD_ALLOW_SEALING | MFD_NOEXEC_SEAL);
size_t total = sizeof(struct shared_header) + data_len;
ftruncate(fd, total);

void *base = mmap(NULL, total,
    PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

struct shared_header *hdr = base;
hdr->magic       = 0xDEADBEEF;
hdr->version     = 1;
hdr->data_offset = sizeof(*hdr);
hdr->data_len    = data_len;
memcpy((char *)base + hdr->data_offset, payload, data_len);

munmap(base, total);
fcntl(fd, F_ADD_SEALS,
    F_SEAL_WRITE | F_SEAL_SHRINK | F_SEAL_GROW | F_SEAL_SEAL);
/* 이제 fd를 SCM_RIGHTS로 전달 */

2. 그래픽 버퍼 (DMA-BUF 대안)

GPU가 없거나 소프트웨어 렌더링을 사용하는 환경에서 memfd는 그래픽 버퍼로 활용됩니다. Wayland의 wl_shm, PipeWire의 memfd 기반 오디오/비디오 버퍼가 대표적입니다.

3. JIT 컴파일러

JavaScript V8, Java HotSpot, LuaJIT 등의 JIT 컴파일러는 memfd를 사용하여 동적 생성 코드를 안전하게 실행합니다. W^X(Write XOR Execute) 원칙을 준수하기 위해:

1. memfd에 MFD_EXEC 플래그로 생성
2. PROT_WRITE로 mmap하여 기계어 코드 기록
3. mprotect()로 PROT_EXEC로 전환 (또는 별도 매핑)
4. 코드 실행

/* JIT: W^X 패턴 with memfd */
int fd = memfd_create("jit-code", MFD_CLOEXEC | MFD_EXEC);
ftruncate(fd, code_size);

/* 쓰기 전용 매핑 */
void *w = mmap(NULL, code_size, PROT_WRITE,
    MAP_SHARED, fd, 0);
memcpy(w, generated_code, code_size);
munmap(w, code_size);

/* 실행 전용 매핑 (다른 가상 주소) */
void *x = mmap(NULL, code_size, PROT_READ | PROT_EXEC,
    MAP_SHARED, fd, 0);

/* JIT 코드 실행 */
((void (*)())x)();

memfd 활용 프로젝트 예시

memfd와 zswap/zram의 운영 경계

memfd와 zswap/zram은 모두 메모리 관리 문맥에서 자주 함께 언급되지만, 역할 계층이 다릅니다. memfd는 사용자 공간의 공유 버퍼를 표현하는 파일 디스크립터 API이고, zswap/zram은 메모리 압박 시 페이지를 압축해 보관하는 스왑 계층입니다.

관측과 디버깅 체크리스트

memfd 장애는 보통 "API 사용 오류"와 "메모리 압박에 따른 간접 영향"이 섞여 나타납니다. 아래 순서대로 보면 원인 분리가 빠릅니다.

1. fd 존재 확인 -- /proc/<pid>/fd에서 memfd:name 링크를 확인
2. 매핑 상태 확인 -- /proc/<pid>/maps와 smaps에서 공유 매핑/권한 확인
3. seal 확인 -- fcntl(fd, F_GET_SEALS) 값으로 불변성 정책 검증
4. 스왑 영향 분리 -- 성능 저하 시 Swapping 문서의 지표로 zswap/zram 개입 여부 확인

# 1) 프로세스가 보유한 memfd 확인
ls -l /proc/$PID/fd | grep memfd

# 2) 매핑된 영역과 권한 확인
grep -n "memfd" /proc/$PID/maps
grep -n "memfd" /proc/$PID/smaps

# 3) fdinfo에서 inode/flags 확인
cat /proc/$PID/fdinfo/$FD

# 4) 전역 메모리 압박 확인 (간접 영향 분리)
cat /proc/meminfo | egrep 'MemAvailable|SwapTotal|SwapFree'
cat /proc/vmstat | egrep 'pswpin|pswpout'

/* seal 상태 점검 유틸리티 */
static void dump_memfd_seals(int fd)
{
    int seals = fcntl(fd, F_GET_SEALS);
    if (seals < 0) {
        perror("F_GET_SEALS");
        return;
    }
    printf("seals=0x%x\\n", seals);
    if (seals & F_SEAL_SEAL)         puts("  - F_SEAL_SEAL");
    if (seals & F_SEAL_SHRINK)       puts("  - F_SEAL_SHRINK");
    if (seals & F_SEAL_GROW)         puts("  - F_SEAL_GROW");
    if (seals & F_SEAL_WRITE)        puts("  - F_SEAL_WRITE");
    if (seals & F_SEAL_FUTURE_WRITE) puts("  - F_SEAL_FUTURE_WRITE");
}

자주 발생하는 장애 패턴

실패 재현 코드: seal 검증 누락 사례

/* 수신 측에서 seal 검증을 누락하면 발생 가능한 실수 */
int recv_fd = recv_fd_over_unix_socket(sock);
void *p = mmap(NULL, size, PROT_READ, MAP_SHARED, recv_fd, 0);

/* 잘못된 가정: 송신 측이 이미 봉인했을 것이라고 믿음 */
if (((char *)p)[0] != expected_magic) {
    /* 런타임에서 가끔 실패: 경쟁 상태로 데이터 변경 가능 */
}

/* 올바른 패턴: 수신 측에서 직접 seal 확인 */
int seals = fcntl(recv_fd, F_GET_SEALS);
if (!(seals & F_SEAL_WRITE)) {
    fprintf(stderr, "untrusted memfd: writable\\n");
    abort();
}

참고자료

• memfd_create(2) - Linux man page
• memfd_secret(2) - Linux man page
• Linux Kernel Documentation: Shared Memory
• LWN.net: memfd and file sealing (2014)
• LWN.net: memfd_secret() in 5.14 (2021)
• LWN.net: Restricting memfd_create() with MFD_NOEXEC_SEAL (2023)
• 커널 소스: mm/memfd.c
• 커널 소스: mm/secretmem.c
• 커널 소스: mm/shmem.c