mprotect (메모리 보호 변경)

Linux 커널 mprotect 시스콜: PROT_READ/WRITE/EXEC/NONE 보호 플래그, do_mprotect_pkey 커널 구현, VMA 분할/병합, 페이지 테이블(Page Table) 업데이트, Memory Protection Keys(MPK), W^X 정책, SELinux/AppArmor 제약, COW 상호작용, JIT 컴파일러/가드 페이지(Page)/샌드박스(Sandbox) 활용 종합 가이드.

개요

mprotect()는 프로세스의 가상 주소 공간(Address Space)에서 이미 매핑된 메모리 영역의 접근 보호 속성을 변경하는 시스콜입니다. POSIX 표준에 정의되어 있으며, 메모리 보안의 핵심 메커니즘 중 하나입니다.

일반적인 사용 시나리오는 다음과 같습니다:

• JIT 컴파일러가 코드 생성 후 메모리를 실행 가능하게 전환
• 가드 페이지를 PROT_NONE으로 설정하여 스택 오버플로(Stack Overflow) 탐지
• 읽기 전용으로 전환하여 데이터 무결성(Integrity) 보장
• 메모리 디버거가 접근 패턴을 추적

#include <sys/mman.h>

/* mprotect 기본 인터페이스 */
int mprotect(void *addr, size_t len, int prot);

/* pkey_mprotect: Memory Protection Keys 확장 */
int pkey_mprotect(void *addr, size_t len, int prot, int pkey);

/*
 * addr : 페이지 정렬된 시작 주소
 * len  : 변경할 영역 크기 (바이트, 페이지 단위로 올림)
 * prot : PROT_READ | PROT_WRITE | PROT_EXEC | PROT_NONE
 * pkey : 메모리 보호 키 (pkey_mprotect 전용, 0~15)
 *
 * 반환: 성공 시 0, 실패 시 -1 (errno 설정)
 */

mprotect 시스콜 인터페이스

mprotect의 보호 플래그는 4가지 기본 값과 아키텍처별 확장으로 구성됩니다. 이 플래그들은 비트 OR로 조합하여 사용합니다.

/* include/uapi/asm-generic/mman-common.h */
#define PROT_NONE      0x0   /* 페이지 접근 불가 */
#define PROT_READ      0x1   /* 페이지 읽기 가능 */
#define PROT_WRITE     0x2   /* 페이지 쓰기 가능 */
#define PROT_EXEC      0x4   /* 페이지 실행 가능 */

#define PROT_GROWSDOWN 0x01000000  /* 스택 하향 확장 */
#define PROT_GROWSUP   0x02000000  /* 상향 확장 (IA-64) */

커널 내부에서 PROT 플래그는 vm_flags로 변환됩니다. 이 변환은 아키텍처별 protection_map[] 테이블을 통해 수행됩니다:

/* mm/mmap.c - PROT 플래그 → VM 플래그 변환 */
static unsigned long calc_vm_prot_bits(unsigned long prot, unsigned long pkey)
{
    return _calc_vm_trans(prot, PROT_READ,  VM_READ)  |
           _calc_vm_trans(prot, PROT_WRITE, VM_WRITE) |
           _calc_vm_trans(prot, PROT_EXEC,  VM_EXEC)  |
           arch_calc_vm_prot_bits(prot, pkey);
}

/* 변환 예시:
 * PROT_READ               → VM_READ
 * PROT_READ | PROT_WRITE  → VM_READ | VM_WRITE
 * PROT_READ | PROT_EXEC   → VM_READ | VM_EXEC
 * PROT_NONE               → 0 (vm_flags에 RWX 비트 없음)
 */

protection_map[16] 전체 매핑 테이블

vm_flags의 VM_READ/VM_WRITE/VM_EXEC/VM_SHARED 4비트 조합(총 16가지)은 protection_map[16] 테이블을 통해 아키텍처별 pgprot_t 값으로 변환됩니다. x86-64에서 각 조합이 PTE 비트에 어떻게 매핑되는지 전체 테이블을 제시합니다.

/* arch/x86/include/asm/pgtable_types.h - x86-64 protection_map */
/* 인덱스: [VM_SHARED][VM_EXEC][VM_WRITE][VM_READ] */
pgprot_t protection_map[16] = {
    [0]  = PAGE_NONE,                    /* ---  → P=0, NX=1 */
    [1]  = PAGE_READONLY,                /* r--  → P=1, R/W=0, NX=1 */
    [2]  = PAGE_COPY,                    /* -w-  → P=1, R/W=0, NX=1 (COW) */
    [3]  = PAGE_COPY,                    /* rw-  → P=1, R/W=0, NX=1 (COW) */
    [4]  = PAGE_READONLY_EXEC,           /* --x  → P=1, R/W=0, NX=0 */
    [5]  = PAGE_READONLY_EXEC,           /* r-x  → P=1, R/W=0, NX=0 */
    [6]  = PAGE_COPY_EXEC,              /* -wx  → P=1, R/W=0, NX=0 (COW) */
    [7]  = PAGE_COPY_EXEC,              /* rwx  → P=1, R/W=0, NX=0 (COW) */
    [8]  = PAGE_NONE,                    /* ---s → P=0, NX=1 (shared) */
    [9]  = PAGE_READONLY,                /* r--s → P=1, R/W=0, NX=1 */
    [10] = PAGE_SHARED,                  /* -w-s → P=1, R/W=1, NX=1 */
    [11] = PAGE_SHARED,                  /* rw-s → P=1, R/W=1, NX=1 */
    [12] = PAGE_READONLY_EXEC,           /* --xs → P=1, R/W=0, NX=0 */
    [13] = PAGE_READONLY_EXEC,           /* r-xs → P=1, R/W=0, NX=0 */
    [14] = PAGE_SHARED_EXEC,             /* -wxs → P=1, R/W=1, NX=0 */
    [15] = PAGE_SHARED_EXEC,             /* rwxs → P=1, R/W=1, NX=0 */
};

VM_MAY* 플래그와 mprotect 권한 한계

mprotect()는 무제한으로 권한을 변경할 수 없습니다. VMA 생성 시 설정되는 VM_MAYREAD, VM_MAYWRITE, VM_MAYEXEC 플래그가 mprotect로 설정 가능한 최대 권한을 제한합니다.

/* mm/mprotect.c - VM_MAY* 검사 */
static int do_mprotect_pkey(...)
{
    /* newflags에서 RWX 부분만 추출 */
    unsigned long newflags = calc_vm_prot_bits(prot, pkey);

    /* VMA의 기존 비RWX 플래그 보존 */
    newflags |= (vma->vm_flags & ~(VM_READ | VM_WRITE | VM_EXEC));

    /* 핵심: VM_MAY* 범위를 초과하면 거부 */
    if ((newflags & ~(VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC
                      | VM_READ  | VM_WRITE  | VM_EXEC))
        != (vma->vm_flags & ~(VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC
                               | VM_READ  | VM_WRITE  | VM_EXEC)))
        return -EACCES;

    /*
     * VM_READ  ⊆ VM_MAYREAD  ? OK : EACCES
     * VM_WRITE ⊆ VM_MAYWRITE ? OK : EACCES
     * VM_EXEC  ⊆ VM_MAYEXEC  ? OK : EACCES
     */
}

/* VM_MAY* 때문에 mprotect가 실패하는 실전 예시 */

/* 1. 읽기 전용으로 열린 파일의 매핑 */
int fd = open("/etc/passwd", O_RDONLY);
void *p = mmap(NULL, 4096, PROT_READ,
               MAP_SHARED, fd, 0);
/* VMA: VM_READ | VM_MAYREAD (VM_MAYWRITE 없음!) */

mprotect(p, 4096, PROT_READ | PROT_WRITE);
/* → -1 (errno=EACCES): VM_WRITE 요청했지만 VM_MAYWRITE 없음 */

/* 2. /proc/PID/smaps에서 VM_MAY* 확인 */
/* VmFlags: rd mr  ← VM_READ + VM_MAYREAD만 있음 */
/*   mr = VM_MAYREAD, mw = VM_MAYWRITE, me = VM_MAYEXEC */

mprotect 커널 구현

mprotect()의 커널 진입점(Entry Point)은 do_mprotect_pkey()입니다. 이 함수는 mm/mprotect.c에 정의되어 있으며, 주소 검증, VMA 순회, LSM 검사, VMA 속성 변경을 담당합니다.

/* mm/mprotect.c - do_mprotect_pkey() 핵심 로직 (v6.x 기준 단순화) */
static int do_mprotect_pkey(unsigned long start, size_t len,
                            unsigned long prot, int pkey)
{
    unsigned long nstart, end, tmp, reqprot;
    struct vm_area_struct *vma, *prev;
    int error;
    const bool rier = (current->personality & READ_IMPLIES_EXEC)
                        && (prot & PROT_READ);

    /* 1. 주소 정렬 및 범위 검증 */
    start = untagged_addr(start);
    prot &= ~(PROT_GROWSDOWN | PROT_GROWSUP);
    if (start & ~PAGE_MASK)
        return -EINVAL;
    len = PAGE_ALIGN(len);
    end = start + len;
    if (end <= start)
        return -ENOMEM;

    /* 2. 요청된 보호를 vm_flags로 변환 */
    reqprot = prot;
    unsigned long newflags = calc_vm_prot_bits(prot, pkey);

    /* 3. VMA 순회: 범위에 걸친 모든 VMA 처리 */
    vma = find_vma(current->mm, start);
    for (nstart = start; nstart < end; nstart = tmp) {
        if (!vma || vma->vm_start >= end)
            return -ENOMEM;

        tmp = vma->vm_end;
        if (tmp > end)
            tmp = end;

        /* 4. LSM(보안 모듈) 검사 */
        error = security_file_mprotect(vma, reqprot, prot);
        if (error)
            return error;

        /* 5. VMA 속성 변경 (분할/병합 포함) */
        error = mprotect_fixup(vma, &prev, nstart, tmp, newflags);
        if (error)
            return error;

        vma = prev->vm_next;
    }
    return 0;
}

do_mprotect_pkey() 호출 체인

mprotect(2) 시스콜은 사용자 공간에서 커널까지 다음과 같은 호출 체인을 따릅니다. 시스콜 진입점에서 시작하여 최종적으로 개별 PTE(Page Table Entry)의 권한 비트를 수정하는 pte_modify()까지 이어지는 계층 구조를 이해하면, mprotect 내부 동작을 정확히 파악할 수 있습니다.

호출 체인의 각 단계는 명확한 역할을 분담합니다:

ftrace를 이용하여 mprotect 시스콜의 호출 체인을 실시간으로 추적하는 방법입니다. 각 함수의 호출 순서와 실행 시간을 확인할 수 있습니다.

# ===== ftrace로 mprotect 호출 체인 추적 =====

# 1. ftrace 설정
cd /sys/kernel/debug/tracing
echo 0 > tracing_on
echo function_graph > current_tracer

# 2. mprotect 관련 함수만 필터링
echo 'do_mprotect_pkey' > set_graph_function
echo 'mprotect_fixup change_protection change_pte_range' >> set_graph_function
echo 'split_huge_pmd vma_merge' >> set_graph_function

# 3. 특정 PID만 추적 (선택 사항)
echo $PID > set_ftrace_pid

# 4. 추적 시작
echo > trace                 # 기존 버퍼 클리어
echo 1 > tracing_on

# 5. 대상 프로그램에서 mprotect 호출
# (다른 터미널에서)
# ./my_program

# 6. 추적 결과 확인
echo 0 > tracing_on
cat trace

# ftrace 출력 예시:
# 3)               |  do_mprotect_pkey() {
#  3)               |    mprotect_fixup() {
#  3)   0.234 us    |      vma_merge();
#  3)               |      change_protection() {
#  3)               |        change_protection_range() {
#  3)   0.892 us    |          change_pte_range();
#  3)   1.456 us    |        }
#  3)   2.103 us    |      }
#  3)   3.547 us    |    }
#  3)   4.211 us    |  }

# bpftrace로 mprotect 호출 인자 추적 (더 상세)
bpftrace -e '
tracepoint:syscalls:sys_enter_mprotect {
    printf("pid=%d addr=0x%lx len=%lu prot=%lu\n",
           pid, args->start, args->len, args->prot);
}
tracepoint:syscalls:sys_exit_mprotect {
    printf("pid=%d ret=%ld\n", pid, args->ret);
}'

# perf로 mprotect 성능 프로파일링
perf stat -e 'syscalls:sys_enter_mprotect' -- ./my_program
perf trace -e mprotect -- ./my_program

VMA 분할과 병합

mprotect가 VMA의 일부만 대상으로 할 때, 커널은 기존 VMA를 분할(split)하고, 보호 속성이 같은 인접 VMA가 있으면 병합(merge)합니다. 이 과정은 mprotect_fixup()에서 수행됩니다.

/* mm/mprotect.c - mprotect_fixup() 핵심 로직 */
int mprotect_fixup(struct vma_iterator *vmi,
    struct vm_area_struct *vma,
    struct vm_area_struct **pprev,
    unsigned long start, unsigned long end,
    unsigned long newflags)
{
    struct mm_struct *mm = vma->vm_mm;
    unsigned long oldflags = vma->vm_flags;
    pgprot_t newprot;

    /* 변경 필요 없음 → 바로 반환 */
    if (newflags == oldflags) {
        *pprev = vma;
        return 0;
    }

    /* 1. 인접 VMA와 병합 시도 */
    vma = vma_merge(vmi, mm, *pprev, start, end,
                    newflags, vma->anon_vma, vma->vm_file,
                    vma->vm_pgoff, vma_policy(vma),
                    vma->vm_userfaultfd_ctx);
    if (vma)
        goto success;

    /* 2. 병합 실패 → 시작 부분 분할 */
    if (start != vma->vm_start) {
        error = split_vma(vmi, vma, start, 1);
        if (error)
            return error;
    }

    /* 3. 끝 부분 분할 */
    if (end != vma->vm_end) {
        error = split_vma(vmi, vma, end, 0);
        if (error)
            return error;
    }

success:
    /* 4. vm_flags 갱신 */
    vm_flags_reset(vma, newflags);
    /* dirty accountting 업데이트 */
    vma_set_page_prot(vma);

    /* 5. 페이지 테이블 업데이트 */
    change_protection(vma, start, end, newprot,
                      dirty_accountable ? MM_CP_DIRTY_ACCT : 0);

    *pprev = vma;
    return 0;
}

vm_area_struct의 mprotect 관련 필드

mprotect 동작을 이해하려면 struct vm_area_struct에서 보호 속성과 관련된 핵심 필드를 파악해야 합니다. mprotect_fixup()은 이 필드들을 직접 수정하고, change_protection()은 이 필드 값을 기반으로 PTE를 갱신합니다.

/* include/linux/mm_types.h - mprotect 관련 핵심 필드 (v6.x 기준) */
struct vm_area_struct {
    unsigned long vm_start;       /* VMA 시작 가상 주소 (페이지 정렬) */
    unsigned long vm_end;         /* VMA 끝 주소 (exclusive, 페이지 정렬) */

    /*
     * vm_flags: VMA 보호 속성 + 매핑 특성
     * mprotect()가 직접 변경하는 핵심 필드
     * VM_READ | VM_WRITE | VM_EXEC | VM_SHARED 등
     */
    vm_flags_t vm_flags;          /* 보호 플래그 (mprotect 변경 대상) */

    /*
     * vm_page_prot: vm_flags를 아키텍처별 PTE 비트로 변환한 값
     * pgprot_t는 x86에서 _PAGE_RW, _PAGE_NX 등을 포함
     * mprotect_fixup()이 vma_set_page_prot()로 재계산
     */
    pgprot_t vm_page_prot;        /* PTE 보호 비트 (아키텍처 종속) */

    struct file *vm_file;         /* 매핑된 파일 (mprotect 시 LSM 검사 대상) */

    const struct vm_operations_struct *vm_ops; /* VMA 연산 테이블 */

    /*
     * vm_pgoff: 파일 매핑 시 오프셋
     * mprotect는 이 값을 변경하지 않음 (보호만 변경)
     */
    unsigned long vm_pgoff;       /* 파일 오프셋 (PAGE_SIZE 단위) */

    /* anon_vma: anonymous 매핑의 역방향 매핑 구조
     * COW 발생 시 mprotect와 상호작용 */
    struct anon_vma *anon_vma;    /* 익명 VMA 역방향 매핑 */
};

VMA 필드를 커널 모듈에서 직접 조회하여 mprotect 동작을 분석하는 예시입니다. /proc/[pid]/maps의 출력과 대응하는 커널 자료 구조를 확인할 수 있습니다.

/* vma_inspect.c — VMA 필드를 커널 모듈에서 조회하는 예시 */
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/mm_types.h>
#include <linux/proc_fs.h>

static int target_pid = 0;
module_param(target_pid, int, 0644);

static void dump_vma_flags(unsigned long flags)
{
    pr_info("  vm_flags: 0x%lx [", flags);
    if (flags & VM_READ)    pr_cont("READ ");
    if (flags & VM_WRITE)   pr_cont("WRITE ");
    if (flags & VM_EXEC)    pr_cont("EXEC ");
    if (flags & VM_SHARED)  pr_cont("SHARED ");
    if (flags & VM_MAYREAD) pr_cont("MAYREAD ");
    if (flags & VM_MAYWRITE)pr_cont("MAYWRITE ");
    if (flags & VM_MAYEXEC) pr_cont("MAYEXEC ");
    if (flags & VM_HUGETLB) pr_cont("HUGETLB ");
    pr_cont("]\n");
}

static int __init vma_inspect_init(void)
{
    struct task_struct *task;
    struct mm_struct *mm;
    struct vm_area_struct *vma;
    struct vma_iterator vmi;
    int count = 0;

    rcu_read_lock();
    task = find_task_by_vpid(target_pid);
    if (!task) {
        rcu_read_unlock();
        pr_err("PID %d를 찾을 수 없습니다\n", target_pid);
        return -ESRCH;
    }
    get_task_struct(task);
    rcu_read_unlock();

    mm = get_task_mm(task);
    if (!mm) {
        put_task_struct(task);
        return -EINVAL;
    }

    mmap_read_lock(mm);
    vma_iter_init(&vmi, mm, 0);
    for_each_vma(vmi, vma) {
        pr_info("VMA [0x%lx - 0x%lx] (%lu KB)\n",
                vma->vm_start, vma->vm_end,
                (vma->vm_end - vma->vm_start) >> 10);
        dump_vma_flags(vma->vm_flags);
        pr_info("  vm_page_prot: 0x%lx, file: %s\n",
                pgprot_val(vma->vm_page_prot),
                vma->vm_file ? file_dentry(vma->vm_file)->d_name.name
                             : "(anonymous)");
        if (++count >= 20) break;  /* 처음 20개만 출력 */
    }
    mmap_read_unlock(mm);

    mmput(mm);
    put_task_struct(task);
    return 0;
}

static void __exit vma_inspect_exit(void) {}

module_init(vma_inspect_init);
module_exit(vma_inspect_exit);
MODULE_LICENSE("GPL");

# 모듈 로드 (대상 PID의 VMA 정보 출력)
insmod vma_inspect.ko target_pid=$$
dmesg | tail -40

# /proc/[pid]/maps와 대조 (유저스페이스에서 확인 가능한 정보)
cat /proc/$$/maps | head -20
# 출력: 주소범위 권한 오프셋 장치 inode 경로
# 5555555000-5555556000 r-xp 00001000 fd:01 1234 /usr/bin/bash

# vm_flags 비트 매핑 확인
# r-xp → VM_READ | VM_EXEC (0x05) + VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC
# rw-p → VM_READ | VM_WRITE (0x03)

mprotect_fixup()이 vm_flags를 갱신하는 핵심 흐름은 다음과 같습니다:

/* mm/mprotect.c - mprotect_fixup() 핵심 로직 (단순화) */
static int mprotect_fixup(struct vm_area_struct *vma,
    struct vm_area_struct **pprev, unsigned long start,
    unsigned long end, unsigned long newflags)
{
    struct mm_struct *mm = vma->vm_mm;
    unsigned long oldflags = vma->vm_flags;
    pgprot_t newprot;

    /* 1. 플래그 변경이 없으면 즉시 반환 */
    if (newflags == oldflags) {
        *pprev = vma;
        return 0;
    }

    /* 2. VMA 분할/병합 */
    vma = vma_modify_flags(vma, pprev, start, end, newflags);

    /* 3. vm_flags 갱신 + vm_page_prot 재계산 */
    vm_flags_reset(vma, newflags);
    /* dirty_accountable: 쓰기 가능→soft dirty 추적 */
    newprot = vm_get_page_prot(newflags);

    /* 4. 페이지 테이블의 실제 PTE 권한 갱신 */
    change_protection(&tlb, vma, start, end, newprot, cp_flags);

    return 0;
}

페이지 테이블 업데이트

VMA 속성이 변경된 후, change_protection()이 호출되어 실제 페이지 테이블 엔트리를 갱신합니다. 이 함수는 페이지 디렉토리 계층을 순회하며 각 PTE의 권한 비트를 수정합니다.

/* mm/mprotect.c - change_protection() → change_pXd_range() 호출 체인 */
unsigned long change_protection(
    struct mmu_gather *tlb,
    struct vm_area_struct *vma,
    unsigned long start, unsigned long end,
    pgprot_t newprot, unsigned long cp_flags)
{
    unsigned long pages;

    BUG_ON((cp_flags & MM_CP_UFFD_WP_ALL) == MM_CP_UFFD_WP_ALL);

    /* TLB gather 시작 */
    tlb_gather_mmu(tlb, vma->vm_mm);

    /* 페이지 디렉토리 계층 순회 */
    pages = change_protection_range(tlb, vma, start, end,
                                     newprot, cp_flags);

    /* TLB 일괄 무효화 */
    tlb_finish_mmu(tlb);

    return pages;
}

/* PTE 레벨 처리 - 가장 하위 단계 */
static unsigned long change_pte_range(
    struct vm_area_struct *vma, pmd_t *pmd,
    unsigned long addr, unsigned long end,
    pgprot_t newprot, unsigned long cp_flags)
{
    pte_t *pte, oldpte, ptent;
    spinlock_t *ptl;
    unsigned long pages = 0;

    pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
    for (; addr < end; pte++, addr += PAGE_SIZE) {
        oldpte = ptep_get(pte);
        if (pte_present(oldpte)) {
            /* PTE 권한 비트 갱신 */
            ptent = pte_modify(oldpte, newprot);
            ptent = pte_mkold(ptent);  /* Accessed 비트 초기화 */
            ptep_modify_prot_commit(vma, addr, pte, oldpte, ptent);
            pages++;
        }
    }
    pte_unmap_unlock(pte - 1, ptl);
    return pages;
}

PROT_NONE 내부 PTE 인코딩

PROT_NONE은 특수한 보호 속성입니다. "접근 불가"를 의미하지만, 커널은 해당 페이지가 여전히 매핑되어 있음을 구분해야 합니다(진짜 "미할당"과 구별). x86-64에서 PROT_NONE 페이지의 PTE 인코딩은 두 가지 방식으로 구현됩니다.

/* arch/x86/include/asm/pgtable.h - PROT_NONE PTE 판별 */

/* 핵심: pte_present()는 Present OR PROTNONE을 모두 참으로 처리 */
static inline int pte_present(pte_t a)
{
    return pte_flags(a) & (_PAGE_PRESENT | _PAGE_PROTNONE);
}

/* 진짜 비어있는(미할당) PTE 검사 */
static inline int pte_none(pte_t pte)
{
    return !(pte_flags(pte) & ~_PAGE_KNL_ERRATUM_MASK);
}

/*
 * _PAGE_PROTNONE 비트 위치: x86-64에서 Global 비트(bit 8)를 재활용
 * - 하드웨어는 Present=0이면 다른 비트를 무시하므로
 *   소프트웨어가 자유롭게 사용 가능
 * - NUMA 밸런싱도 이 메커니즘을 재활용
 */
#define _PAGE_PROTNONE  (_AT(pteval_t, 1) << _PAGE_BIT_PROTNONE)

PROT_NONE은 다음과 같은 용도로 활용됩니다:

change_pte_range() 함수 구현 분석

change_pte_range()는 mprotect 호출 체인의 최하위 함수로, 실제 PTE 엔트리를 하나씩 순회하며 권한 비트를 수정합니다. 이 함수는 swap 엔트리(Swap Entry), NUMA 밸런싱(Balancing), userfaultfd write-protect, soft-dirty 추적 등 다양한 조건을 처리하는 복잡한 로직을 포함합니다. 아래는 v6.x 커널 기준으로 핵심 경로를 단순화한 코드입니다.

/* mm/mprotect.c - change_pte_range() 분석 (v6.x 단순화) */
static unsigned long change_pte_range(
    struct vm_area_struct *vma, pmd_t *pmd,
    unsigned long addr, unsigned long end,
    pgprot_t newprot, unsigned long cp_flags)
{
    pte_t *pte, oldpte, ptent;
    spinlock_t *ptl;
    unsigned long pages = 0;
    int target_node = NUMA_NO_NODE;
    bool uffd_wp = cp_flags & MM_CP_UFFD_WP;
    bool uffd_wp_resolve = cp_flags & MM_CP_UFFD_WP_RESOLVE;

    /* PTE 테이블 매핑 + spinlock 획득 */
    pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
    if (!pte)
        return 0;

    /* 아키텍처별 TLB 일괄 처리 시작 */
    arch_enter_lazy_mmu_mode();

    for (; addr < end; pte++, addr += PAGE_SIZE) {
        oldpte = ptep_get(pte);

        if (pte_present(oldpte)) {
            /* ── 1단계: present PTE 처리 ── */
            pte_t ptent;

            /* NUMA 밸런싱: 타겟 노드가 아니면 PROT_NONE으로 설정 */
            if (cp_flags & MM_CP_PROT_NUMA) {
                struct folio *folio = vm_normal_folio(vma, addr, oldpte);
                if (!folio || folio_is_zone_device(folio))
                    continue;
                if (folio_nid(folio) == target_node)
                    continue;
            }

            /* 기존 PTE에서 권한 비트만 교체 (PFN 유지) */
            oldpte = ptep_modify_prot_start(vma, addr, pte);
            ptent = pte_modify(oldpte, newprot);

            /* soft-dirty 추적 유지 */
            if (pte_soft_dirty(oldpte))
                ptent = pte_mksoft_dirty(ptent);

            /* userfaultfd write-protect 적용/해제 */
            if (uffd_wp)
                ptent = pte_mkuffd_wp(ptent);
            else if (uffd_wp_resolve)
                ptent = pte_clear_uffd_wp(ptent);

            /* 원자적 PTE 교체 완료 */
            ptep_modify_prot_commit(vma, addr, pte, oldpte, ptent);
            pages++;

        } else if (is_swap_pte(oldpte)) {
            /* ── 2단계: swap PTE 처리 ── */
            swp_entry_t entry = pte_to_swp_entry(oldpte);

            /* swap 엔트리도 soft-dirty / uffd-wp 비트 갱신 */
            if (uffd_wp && !pte_swp_uffd_wp(oldpte))
                ptent = pte_swp_mkuffd_wp(oldpte);
            else if (uffd_wp_resolve && pte_swp_uffd_wp(oldpte))
                ptent = pte_swp_clear_uffd_wp(oldpte);

            set_pte_at(vma->vm_mm, addr, pte, ptent);
            pages++;
        }
    }

    arch_leave_lazy_mmu_mode();
    pte_unmap_unlock(pte - 1, ptl);

    return pages;
}

페이지 테이블 워크 코드 분석

change_protection_range()는 4/5단계 페이지 테이블을 최상위(PGD)부터 최하위(PTE)까지 계층적으로 순회합니다. 각 레벨에서 해당 인덱스의 엔트리가 유효한지(present) 확인하고, 다음 레벨의 테이블 주소를 추출하여 한 단계 아래로 내려갑니다. 리눅스 커널은 5단계 페이지 테이블(PGD → P4D → PUD → PMD → PTE)을 지원하지만, 실제 하드웨어가 4단계만 사용하면 P4D는 폴딩(Folding)됩니다.

/* mm/mprotect.c - 페이지 테이블 워크 (단순화) */

/* 최상위: PGD → P4D 순회 */
static unsigned long change_protection_range(
    struct mmu_gather *tlb,
    struct vm_area_struct *vma,
    unsigned long addr, unsigned long end,
    pgprot_t newprot, unsigned long cp_flags)
{
    pgd_t *pgd;
    unsigned long next, pages = 0;

    pgd = pgd_offset(vma->vm_mm, addr);
    do {
        next = pgd_addr_end(addr, end);
        if (pgd_none_or_clear_bad(pgd))
            continue;
        pages += change_p4d_range(tlb, vma, pgd,
                                    addr, next, newprot, cp_flags);
    } while (pgd++, addr = next, addr != end);

    return pages;
}

/* PMD 레벨: Huge Page 검사 후 PTE로 하강 */
static unsigned long change_pmd_range(
    struct mmu_gather *tlb,
    struct vm_area_struct *vma, pud_t *pud,
    unsigned long addr, unsigned long end,
    pgprot_t newprot, unsigned long cp_flags)
{
    pmd_t *pmd;
    unsigned long next, pages = 0;

    pmd = pmd_offset(pud, addr);
    do {
        next = pmd_addr_end(addr, end);

        /* THP(Transparent Huge Page) 2MB 매핑 검사 */
        if (is_swap_pmd(*pmd) || pmd_trans_huge(*pmd)
                || pmd_devmap(*pmd)) {
            /* 2MB 단위로 권한 변경 (PTE 순회 불필요) */
            if (pmd_trans_huge(*pmd)) {
                pages += change_huge_pmd(tlb, vma, pmd,
                                           addr, newprot, cp_flags);
                continue;
            }
        }

        if (pmd_none_or_clear_bad(pmd))
            continue;

        /* PTE 레벨로 하강 */
        pages += change_pte_range(vma, pmd, addr, next,
                                    newprot, cp_flags);
    } while (pmd++, addr = next, addr != end);

    return pages;
}

pkey와 MPK (Memory Protection Keys)

Intel의 Memory Protection Keys(MPK)는 하드웨어 기반의 고속 메모리 보호 메커니즘입니다. 각 페이지에 4비트 보호 키(pkey, 0~15)를 할당하고, 사용자 공간에서 PKRU(Protection Key Rights for User pages) 레지스터(Register)를 직접 수정하여 시스콜 없이 접근 권한을 전환할 수 있습니다.

/* pkey_mprotect() 시스콜로 메모리에 보호 키 할당 */
#include <sys/mman.h>

int pkey = pkey_alloc(0, PKEY_DISABLE_WRITE);
if (pkey == -1) perror("pkey_alloc");

/* 메모리 영역에 pkey 할당 */
void *buf = mmap(NULL, 4096, PROT_READ | PROT_WRITE,
                 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
pkey_mprotect(buf, 4096, PROT_READ | PROT_WRITE, pkey);

/* PKRU 레지스터로 접근 제어 (시스콜 없이!) */
pkey_set(pkey, PKEY_DISABLE_WRITE);  /* 쓰기 차단 */
/* buf에 쓰기 시도 → SIGSEGV */

pkey_set(pkey, 0);                    /* 모든 접근 허용 */
/* buf에 정상 접근 가능 */

pkey_free(pkey);  /* 보호 키 해제 */

W^X 정책 (Write XOR Execute)

W^X(Write XOR Execute)는 메모리 페이지가 동시에 쓰기 가능(W)이면서 실행 가능(X)일 수 없는 보안 정책입니다. 이 정책은 코드 주입 공격(buffer overflow → shellcode 실행)을 방지하는 핵심 메커니즘입니다.

/* mm/mprotect.c - W^X 위반 탐지 (커널 v5.8+ 경고) */
static bool is_wx_mapping(unsigned long vm_flags)
{
    return (vm_flags & (VM_WRITE | VM_EXEC)) == (VM_WRITE | VM_EXEC);
}

/* SELinux에서 W^X 강제 적용 */
static int selinux_file_mprotect(
    struct vm_area_struct *vma,
    unsigned long reqprot, unsigned long prot)
{
    /* execmem 권한 없이 W+X 동시 요청 → -EACCES */
    if ((prot & PROT_EXEC) &&
        !(vma->vm_flags & VM_EXEC)) {
        /* 실행 권한 추가 시 execmem 권한 필요 */
        return avc_has_perm(sid, sid,
            SECCLASS_PROCESS, PROCESS__EXECMEM, NULL);
    }
    return 0;
}

SELinux/AppArmor와 mprotect 제약

LSM(Linux Security Module) 프레임워크는 mprotect 호출 시 security_file_mprotect() 훅을 통해 보안 정책을 강제합니다. SELinux와 AppArmor는 각각 다른 방식으로 mprotect를 제한합니다.

/* security/selinux/hooks.c - SELinux mprotect 검사 로직 */
static int selinux_file_mprotect(
    struct vm_area_struct *vma,
    unsigned long reqprot, unsigned long prot)
{
    const struct cred *cred = current_cred();

    if (prot & PROT_EXEC) {
        if (vma->vm_flags & VM_EXEC)
            return 0;  /* 이미 실행 가능 → 통과 */

        if (vma->vm_file) {
            /* 파일 매핑: execmod 권한 검사 */
            if (vma->anon_vma)  /* COW 후 수정된 매핑 */
                return file_has_perm(cred, vma->vm_file,
                    FILE__EXECMOD);
        } else {
            /* 익명 매핑: execmem 권한 검사 */
            return avc_has_perm(
                current_sid(), current_sid(),
                SECCLASS_PROCESS,
                PROCESS__EXECMEM, NULL);
        }
    }
    return 0;
}

mprotect와 COW (Copy-On-Write) 상호작용

mprotect와 COW는 복잡하게 상호작용합니다. 특히 쓰기 가능 → 읽기 전용으로 변경할 때, 기존 COW 상태의 페이지 처리가 핵심입니다.

/* mprotect_fixup()에서 dirty accounting 처리 */
static int mprotect_fixup(...)
{
    int dirty_accountable = 0;

    /* 쓰기 가능 → 쓰기 불가 전환 시 */
    if ((oldflags & VM_WRITE) && !(newflags & VM_WRITE)) {
        /* 공유 매핑이면 dirty accounting 갱신 필요 */
        if (vma->vm_file && (vma->vm_flags & VM_SHARED))
            dirty_accountable = 1;
    }

    /* 읽기 전용 → 쓰기 가능 전환 시 */
    if (!(oldflags & VM_WRITE) && (newflags & VM_WRITE)) {
        /*
         * COW 페이지는 여전히 읽기 전용 PTE를 유지합니다.
         * 실제 쓰기 시도 시 write fault가 발생하여 COW 복사가 이루어집니다.
         * vm_flags에 VM_WRITE만 설정하고, PTE의 R/W 비트는
         * COW 페이지에 대해서는 변경하지 않습니다.
         */
    }

    /* change_protection()은 COW 페이지의 PTE를 */
    /* 쓰기 가능으로 만들지 않습니다. */
    /* → write fault → do_wp_page() → COW 복사 유지 */
}

핵심 포인트: mprotect로 PROT_WRITE를 추가해도, COW 상태의 페이지는 PTE에서 읽기 전용을 유지합니다. 실제 쓰기 시 write fault가 발생하여 정상적인 COW 복사가 이루어집니다. 이는 fork() 후의 메모리 안전성을 보장합니다.

/* fork() → mprotect PROT_WRITE 시나리오 */
pid_t pid = fork();
if (pid == 0) {  /* 자식 프로세스 */
    /*
     * fork() 후 부모/자식은 동일한 물리 페이지를 공유
     * PTE는 읽기 전용으로 설정 (COW 상태)
     *
     * 자식이 mprotect(addr, len, PROT_READ | PROT_WRITE)를 호출해도
     * COW 페이지의 PTE.R/W는 여전히 0
     * → 쓰기 시도 → write fault → do_wp_page() → COW 복사
     * → 새 물리 페이지에서 쓰기 진행
     */
    mprotect(shared_buf, 4096, PROT_READ | PROT_WRITE);
    shared_buf[0] = 42;  /* write fault → COW 복사 → 쓰기 */
}

mprotect와 시그널 핸들링 (SIGSEGV 복구)

mprotect로 보호된 메모리에 접근하면 SIGSEGV가 발생합니다. 시그널 핸들러에서 접근 위반 원인을 분석하고, mprotect로 권한을 복원하여 프로그램을 계속 실행하는 기법은 가비지 컬렉터(GC), 메모리 디버거, 체크포인팅 시스템 등에서 널리 사용됩니다.

#include <signal.h>
#include <sys/mman.h>
#include <stdint.h>

/* 보호된 메모리 영역 정보 */
static void *tracked_region;
static size_t tracked_size;
static volatile int write_detected;

/* SIGSEGV 핸들러: 쓰기 접근 추적 + 권한 복구 */
static void segv_handler(int sig, siginfo_t *info, void *ucontext)
{
    void *fault_addr = info->si_addr;

    /* 우리가 추적 중인 영역인지 확인 */
    if (info->si_code == SEGV_ACCERR &&
        fault_addr >= tracked_region &&
        fault_addr < tracked_region + tracked_size) {

        /* 해당 페이지를 dirty로 마킹 */
        uintptr_t page = (uintptr_t)fault_addr & ~(4095UL);
        write_detected++;

        /* 권한 복원: 쓰기 허용 → 핸들러 반환 후 명령 재실행 */
        mprotect((void *)page, 4096, PROT_READ | PROT_WRITE);
        return;  /* 폴트 명령으로 복귀 → 정상 실행 */
    }

    /* 추적 영역이 아니면 기본 SIGSEGV 처리 */
    _exit(139);  /* 128 + SIGSEGV(11) */
}

/* 사용 예시: 쓰기 추적 설정 */
void setup_write_tracking(void *region, size_t size)
{
    tracked_region = region;
    tracked_size = size;

    /* SA_SIGINFO로 siginfo_t 수신 활성화 */
    struct sigaction sa = {
        .sa_sigaction = segv_handler,
        .sa_flags = SA_SIGINFO,
    };
    sigemptyset(&sa.sa_mask);
    sigaction(SIGSEGV, &sa, NULL);

    /* 읽기 전용으로 설정 → 쓰기 시 SIGSEGV 발생 */
    mprotect(region, size, PROT_READ);
}

이 패턴은 다음 시스템에서 실제로 사용됩니다:

pkey_mprotect 시스콜

pkey_mprotect()는 Linux 4.9에서 추가된 시스콜로, 기존 mprotect의 기능에 Memory Protection Key(pkey) 할당을 결합합니다.

/* mm/mprotect.c - pkey_mprotect 시스콜 정의 */
SYSCALL_DEFINE4(pkey_mprotect,
    unsigned long, start,
    size_t, len,
    unsigned long, prot,
    int, pkey)
{
    return do_mprotect_pkey(start, len, prot, pkey);
}

/* mprotect는 pkey=-1로 호출 */
SYSCALL_DEFINE3(mprotect,
    unsigned long, start,
    size_t, len,
    unsigned long, prot)
{
    return do_mprotect_pkey(start, len, prot, -1);
}

/* pkey 관련 시스콜 패밀리 */
SYSCALL_DEFINE2(pkey_alloc, unsigned long, flags, unsigned long, init_val)
{
    /* 사용 가능한 pkey 할당 (0~15) */
    int pkey = mm_pkey_alloc(current->mm);
    if (pkey < 0)
        return pkey;
    /* PKRU에 초기 권한 설정 */
    arch_set_user_pkey_access(current, pkey, init_val);
    return pkey;
}

SYSCALL_DEFINE1(pkey_free, int, pkey)
{
    return mm_pkey_free(current->mm, pkey);
}

아래는 유저스페이스에서 MPK(Memory Protection Keys)를 활용하는 전체 흐름 예시입니다. pkey_alloc()으로 키를 할당하고, pkey_mprotect()로 메모리 영역에 키를 바인딩한 뒤, pkey_set()(WRPKRU 명령)으로 실시간 접근 권한을 전환합니다.

/* pkey_demo.c — MPK를 이용한 메모리 보호 전체 흐름 */
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>

/* PKRU 레지스터 직접 조작 (glibc에 pkey_set이 없을 때) */
static inline void wrpkru(unsigned int pkru)
{
    unsigned int ecx = 0, edx = 0;
    asm volatile(".byte 0x0f,0x01,0xef\n\t"
                 : : "a"(pkru), "c"(ecx), "d"(edx));
}

static inline unsigned int rdpkru(void)
{
    unsigned int ecx = 0, pkru;
    asm volatile(".byte 0x0f,0x01,0xee\n\t"
                 : "=a"(pkru) : "c"(ecx) : "edx");
    return pkru;
}

/* pkey 비트 위치: 각 키는 2비트 (AD=접근금지, WD=쓰기금지) */
#define PKEY_DISABLE_ACCESS  0x1
#define PKEY_DISABLE_WRITE   0x2

static void pkey_set(int pkey, unsigned int rights)
{
    unsigned int pkru = rdpkru();
    pkru &= ~(0x3 << (2 * pkey));     /* 기존 비트 클리어 */
    pkru |= (rights << (2 * pkey));   /* 새 권한 설정 */
    wrpkru(pkru);
}

static void sigsegv_handler(int sig, siginfo_t *si, void *unused)
{
    printf("SIGSEGV: addr=%p, si_code=%d (PKE=%d)\n",
           si->si_addr, si->si_code,
           si->si_code == 5);  /* SEGV_PKUERR=5 */
    _exit(1);
}

int main(void)
{
    struct sigaction sa = { .sa_sigaction = sigsegv_handler,
                            .sa_flags = SA_SIGINFO };
    sigaction(SIGSEGV, &sa, NULL);

    /* 1. 메모리 영역 할당 */
    size_t size = 4096;
    void *secret = mmap(NULL, size, PROT_READ | PROT_WRITE,
                        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    strcpy(secret, "sensitive data");

    /* 2. 보호 키 할당 (키 0은 기본, 1~15 사용 가능) */
    int pkey = pkey_alloc(0, 0);
    if (pkey < 0) {
        perror("pkey_alloc (MPK 미지원?)");
        return 1;
    }
    printf("할당된 pkey=%d\n", pkey);

    /* 3. pkey_mprotect로 메모리에 키 바인딩 */
    if (pkey_mprotect(secret, size, PROT_READ | PROT_WRITE, pkey)) {
        perror("pkey_mprotect");
        return 1;
    }

    /* 4. 정상 접근 (키 권한: 읽기+쓰기 허용) */
    printf("정상 읽기: %s\n", (char *)secret);

    /* 5. 쓰기 금지 설정 (PKRU 변경, 시스콜 불필요) */
    pkey_set(pkey, PKEY_DISABLE_WRITE);
    printf("읽기 전용 모드 (PKRU=0x%08x)\n", rdpkru());
    printf("읽기 성공: %s\n", (char *)secret);

    /* 6. 접근 완전 차단 */
    pkey_set(pkey, PKEY_DISABLE_ACCESS);
    printf("접근 차단 모드 → 다음 읽기에서 SIGSEGV 발생\n");
    printf("읽기 시도: %s\n", (char *)secret);  /* SIGSEGV! */

    pkey_free(pkey);
    munmap(secret, size);
    return 0;
}

# MPK 하드웨어 지원 확인
grep -o pku /proc/cpuinfo | head -1    # "pku" 출력 시 지원

# 빌드 및 실행
gcc -O2 -o pkey_demo pkey_demo.c
./pkey_demo
# 출력 예시:
# 할당된 pkey=1
# 정상 읽기: sensitive data
# 읽기 전용 모드 (PKRU=0x55555554)
# 읽기 성공: sensitive data
# 접근 차단 모드 → 다음 읽기에서 SIGSEGV 발생
# SIGSEGV: addr=0x7f..., si_code=5 (PKE=1)

커널 설정과 보안 강화

mprotect 관련 커널 설정과 보안 강화 옵션을 정리합니다.

# 커널 빌드 설정에서 MPK 관련 옵션 확인
$ zcat /proc/config.gz | grep -i pkey
CONFIG_X86_INTEL_MEMORY_PROTECTION_KEYS=y
CONFIG_ARCH_HAS_PKEYS=y

# 런타임에서 MPK 지원 여부 확인
$ grep pku /proc/cpuinfo
flags : ... pku ospke ...

# 현재 프로세스의 PKRU 값 확인
$ cat /proc/self/arch_status
AVX512_elapsed_ms:  -1
PKRU:   0x55555554

# mprotect 추적 (ftrace)
$ echo 1 > /sys/kernel/debug/tracing/events/syscalls/sys_enter_mprotect/enable
$ cat /sys/kernel/debug/tracing/trace_pipe

/proc/PID/smaps에서 VMA 보호 속성을 확인할 수 있습니다:

7f8a12000000-7f8a12400000 r-xp 00000000 fd:01 12345  /usr/lib/libc.so.6
    ^^^
    r = PROT_READ
    - = no PROT_WRITE
    x = PROT_EXEC
    p = MAP_PRIVATE

VmFlags: rd ex mr mw me sd
    rd = VM_READ
    ex = VM_EXEC
    mr = VM_MAYREAD
    mw = VM_MAYWRITE  (mprotect으로 쓰기 추가 가능)
    me = VM_MAYEXEC
    sd = VM_SOFTDIRTY

mprotect 활용 패턴

JIT 컴파일러 패턴

JIT(Just-In-Time) 컴파일러는 런타임에 기계어(Machine Code) 코드를 생성하고 실행합니다. W^X 정책을 준수하면서 코드를 생성하려면 mprotect를 활용해야 합니다.

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

/* JIT 컴파일러의 안전한 코드 생성 패턴 */
void *jit_compile(const uint8_t *bytecode, size_t len)
{
    size_t page_size = sysconf(_SC_PAGESIZE);
    size_t alloc_size = (len + page_size - 1) & ~(page_size - 1);

    /* 1단계: RW로 할당 (쓰기 가능, 실행 불가) */
    void *mem = mmap(NULL, alloc_size,
        PROT_READ | PROT_WRITE,
        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (mem == MAP_FAILED) return NULL;

    /* 2단계: 기계어 코드 작성 */
    generate_native_code(mem, bytecode, len);

    /* 3단계: RX로 전환 (읽기+실행 가능, 쓰기 불가) */
    if (mprotect(mem, alloc_size, PROT_READ | PROT_EXEC) != 0) {
        munmap(mem, alloc_size);
        return NULL;
    }

    return mem;  /* 함수 포인터로 호출 가능 */
}

/* 사용 예시 */
typedef int (*jit_func_t)(int);
jit_func_t fn = (jit_func_t)jit_compile(bytecode, bytecode_len);
int result = fn(42);  /* JIT 코드 실행 */

가드 페이지 패턴

/* 가드 페이지를 이용한 버퍼 오버플로 탐지 */
void *alloc_guarded(size_t size)
{
    size_t page_size = sysconf(_SC_PAGESIZE);
    size_t total = page_size + size + page_size;

    /* 전체 영역 할당 */
    void *base = mmap(NULL, total,
        PROT_READ | PROT_WRITE,
        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

    /* 앞쪽 가드 페이지: PROT_NONE (접근 시 SIGSEGV) */
    mprotect(base, page_size, PROT_NONE);

    /* 뒤쪽 가드 페이지: PROT_NONE */
    mprotect(base + page_size + size, page_size, PROT_NONE);

    /* 사용 가능한 영역 반환 */
    return base + page_size;
}

/*
 * 메모리 레이아웃:
 * [GUARD: PROT_NONE][사용 가능: RW][GUARD: PROT_NONE]
 * ← 언더플로 탐지  →← 실제 데이터 →← 오버플로 탐지 →
 */

스택 보호 (glibc pthread)

/* glibc에서 스레드 스택 가드 페이지 설정 (nptl/allocatestack.c) */
static int allocate_stack(const struct pthread_attr *attr,
                          struct pthread **pdp, ...)
{
    /* 스택 + 가드 페이지 할당 */
    size_t guardsize = attr->guardsize;
    void *mem = mmap(NULL, stacksize + guardsize, ...);

    /* 스택 하단에 가드 페이지 설정 */
    if (guardsize > 0) {
        /* 스택은 아래로 성장하므로 하단에 PROT_NONE */
        mprotect(mem, guardsize, PROT_NONE);
    }
    /*
     * 스택 레이아웃 (x86-64):
     *   높은 주소 → [스택 사용 영역 (RW)]
     *              [TLS/TCB]
     *   낮은 주소 → [가드 페이지 (PROT_NONE)]
     *
     * 스택 오버플로 시 가드 페이지 접근 → SIGSEGV
     */
}

성능 특성과 주의사항

mprotect의 성능은 대상 영역의 크기와 매핑된 페이지 수에 비례합니다. 주요 비용 요소를 이해하고 최적화하는 것이 중요합니다.

실전 사용 사례

JIT 컴파일러 (V8, LuaJIT, Java HotSpot)

V8 엔진(Chrome/Node.js)은 JavaScript를 기계어로 컴파일할 때 mprotect를 사용합니다. 코드 생성 시 RW, 실행 시 RX로 전환하며, MPK를 지원하는 플랫폼에서는 pkey를 활용합니다.

/* V8 엔진의 코드 페이지 관리 (단순화) */
class CodePageAllocator {
    void* AllocateCode(size_t size) {
        /* MPK 사용 가능하면 pkey 할당 */
        if (has_mpk_support_) {
            void* mem = mmap(..., PROT_READ | PROT_WRITE, ...);
            pkey_mprotect(mem, size,
                PROT_READ | PROT_WRITE, code_pkey_);
            return mem;
        }
        /* 폴백: 일반 mprotect 패턴 */
        return mmap(..., PROT_READ | PROT_WRITE, ...);
    }

    void MakeExecutable(void* addr, size_t size) {
        if (has_mpk_support_) {
            /* WRPKRU로 쓰기 차단 (초고속) */
            pkey_set(code_pkey_, PKEY_DISABLE_WRITE);
        } else {
            mprotect(addr, size, PROT_READ | PROT_EXEC);
        }
    }
};

메모리 디버거 (Valgrind, AddressSanitizer)

/* AddressSanitizer: redzones를 PROT_NONE으로 설정 */
/* 버퍼 오버플로/언더플로를 즉시 탐지 */
void asan_poison_region(void *addr, size_t size)
{
    /* redzone 영역을 접근 불가로 설정 */
    mprotect(addr, size, PROT_NONE);
    /* 이 영역 접근 시 SIGSEGV → 오류 보고 */
}

void asan_unpoison_region(void *addr, size_t size)
{
    /* 해제된 메모리를 다시 사용 가능하게 복원 */
    mprotect(addr, size, PROT_READ | PROT_WRITE);
}

샌드박스 (seccomp + mprotect)

/* Chrome의 샌드박스: seccomp-BPF로 mprotect 제한 */
struct sock_filter filter[] = {
    /* mprotect 시스콜 허용, 단 PROT_EXEC 금지 */
    BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
        offsetof(struct seccomp_data, nr)),
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K,
        __NR_mprotect, 0, 3),
    /* 3번째 인자(prot)에 PROT_EXEC가 있으면 거부 */
    BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
        offsetof(struct seccomp_data, args[2])),
    BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K,
        PROT_EXEC, 0, 1),
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ERRNO | EACCES),
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
};

TLB Shootdown과 멀티코어 비용

mprotect는 VMA 플래그만 바꾸는 것으로 끝나지 않습니다. 이미 CPU TLB에 캐시(Cache)된 변환 정보가 남아 있으면 예전 권한으로 접근할 수 있으므로, 권한 변경 후에는 TLB 무효화가 필요합니다. 단일 코어에서는 로컬 플러시로 끝나지만, 멀티코어에서는 해당 mm를 실행 중인 모든 CPU로 IPI를 보내는 TLB shootdown 경로가 발생합니다.

/* 개념 요약: mprotect 경로의 TLB 플러시 처리 */
int do_mprotect_pkey(...)
{
    struct mmu_gather tlb;

    tlb_gather_mmu(&tlb, mm);
    mprotect_fixup(vma, &prev, start, end, newflags);
    tlb_finish_mmu(&tlb, start, end); /* 필요 범위 TLB flush */
    return 0;
}

THP 및 HugeTLB 매핑에서의 mprotect

4KB 페이지에서는 PTE 단위로 권한이 바뀌지만, THP(예: PMD 크기 2MB)나 HugeTLB(예: 2MB/1GB)에서는 처리 경로가 달라집니다. 일부 경우 mprotect가 huge mapping을 분할(split)해 일반 페이지로 내려오며, 이 과정에서 성능과 메모리 단편화(Fragmentation)에 영향을 줄 수 있습니다.

THP와 mprotect의 상호작용을 직접 확인하는 코드입니다. THP가 활성화된 상태에서 부분 범위 mprotect를 호출하면 split이 발생하는 과정을 추적합니다.

/* thp_mprotect_demo.c — THP split 발생 조건 확인 */
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>

#define THP_SIZE  (2UL * 1024 * 1024)   /* 2MB = PMD 크기 */

static void show_smaps(void *addr, const char *label)
{
    char cmd[256];
    printf("\n=== %s (addr=%p) ===\n", label, addr);
    snprintf(cmd, sizeof(cmd),
             "grep -A5 '%lx' /proc/%d/smaps | "
             "grep -E 'AnonHugePages|THPeligible|VmFlags'",
             (unsigned long)addr, getpid());
    system(cmd);
}

int main(void)
{
    /* 1. 2MB 정렬 매핑 (THP 친화적) */
    void *area = mmap(NULL, THP_SIZE * 4,
                      PROT_READ | PROT_WRITE,
                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (area == MAP_FAILED) { perror("mmap"); return 1; }

    /* THP 요청 힌트 */
    madvise(area, THP_SIZE * 4, MADV_HUGEPAGE);

    /* 2. 전체 영역 터치 → THP 할당 유도 */
    memset(area, 0xAA, THP_SIZE * 4);
    show_smaps(area, "THP 할당 후");

    /* 3. 전체 2MB 범위에 mprotect → split 미발생 */
    mprotect(area, THP_SIZE, PROT_READ);
    show_smaps(area, "전체 THP 범위 mprotect(RD)");

    /* 4. 부분 범위 mprotect → split_huge_pmd() 발생! */
    void *mid = (char *)area + THP_SIZE + (64 * 1024);
    mprotect(mid, 64 * 1024, PROT_READ | PROT_EXEC);
    show_smaps((char *)area + THP_SIZE,
              "부분 범위 mprotect(RX) → THP split");

    /* 5. split 발생 통계 확인 */
    printf("\n=== THP split 통계 ===\n");
    system("grep thp_split /proc/vmstat");

    munmap(area, THP_SIZE * 4);
    return 0;
}

# THP split 발생 추적 (ftrace)
echo 1 > /sys/kernel/debug/tracing/events/huge_memory/mm_khugepaged_scan_pmd/enable
echo 1 > /sys/kernel/debug/tracing/events/thp/thp_split_pmd/enable

# 프로그램 실행 후 trace 확인
./thp_mprotect_demo
cat /sys/kernel/debug/tracing/trace | grep thp_split

# JIT 워크로드에서 THP 비활성화 (split 반복 방지)
madvise(jit_area, jit_size, MADV_NOHUGEPAGE);
# 또는 시스템 전체 비활성화
echo never > /sys/kernel/mm/transparent_hugepage/enabled

userfaultfd Write-Protect와 mprotect 차이

userfaultfd의 write-protect(UFFD-WP)는 페이지 단위 쓰기 보호(Write Protection)를 사용자 공간 페이저가 관찰하고 제어할 수 있게 합니다. 겉보기에는 mprotect(PROT_READ)와 유사하지만, 목적과 fault 처리 모델이 다릅니다.

/* userfaultfd write-protect 예시 (요약) */
int uffd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);
struct uffdio_api api = { .api = UFFD_API };
ioctl(uffd, UFFDIO_API, &api);

struct uffdio_register reg = {
    .range = { .start = (unsigned long)addr, .len = len },
    .mode  = UFFDIO_REGISTER_MODE_WP,
};
ioctl(uffd, UFFDIO_REGISTER, &reg);

struct uffdio_writeprotect wp = {
    .range = { .start = (unsigned long)addr, .len = len },
    .mode  = UFFDIO_WRITEPROTECT_MODE_WP,
};
ioctl(uffd, UFFDIO_WRITEPROTECT, &wp);

mprotect 진단: ftrace, perf, BPF

문제가 "권한 전환 실패"인지, "성능 저하"인지 구분해 계측해야 합니다. 커널 함수 추적, 시스콜 이벤트, IPI/TLB 카운터를 함께 보면 병목을 빠르게 좁힐 수 있습니다.

# 1) 시스콜 레벨 지연 추적
perf trace -e mprotect,pkey_mprotect -p <pid>

# 2) 커널 함수 샘플링 (ftrace function_graph)
echo function_graph > /sys/kernel/debug/tracing/current_tracer
echo do_mprotect_pkey > /sys/kernel/debug/tracing/set_graph_function
echo 1 > /sys/kernel/debug/tracing/tracing_on
sleep 3
echo 0 > /sys/kernel/debug/tracing/tracing_on
cat /sys/kernel/debug/tracing/trace

# 3) BPF로 지연 히스토그램 집계 (예: bpftrace)
bpftrace -e 'kprobe:do_mprotect_pkey { @ts[tid] = nsecs; }
kretprobe:do_mprotect_pkey /@ts[tid]/ { @us = hist((nsecs-@ts[tid])/1000); delete(@ts[tid]); }'

아키텍처별 차이 (x86-64 vs ARM64)

mprotect의 커널 코드(mm/mprotect.c)는 아키텍처에 독립적이지만, 실제 PTE 인코딩과 하드웨어 보호 메커니즘은 아키텍처마다 크게 다릅니다. x86-64와 ARM64의 주요 차이를 비교합니다.

NUMA 밸런싱과 mprotect 재사용

Linux의 자동 NUMA 밸런싱(AutoNUMA)은 mprotect의 change_protection() 코드를 재사용하여 페이지를 PROT_NONE으로 만들고, 접근 fault를 통해 각 페이지의 최적 NUMA 노드를 결정합니다. 이 메커니즘은 mprotect 시스콜을 호출하지 않지만, 내부적으로 동일한 PTE 수정 경로를 사용합니다.

/* kernel/sched/fair.c - AutoNUMA 스캐너 */
static void task_numa_work(struct callback_head *work)
{
    struct mm_struct *mm = current->mm;
    struct vm_area_struct *vma;
    unsigned long start, end;

    /* 주기적으로 VMA를 스캔하며 PROT_NONE 설정 */
    for_each_vma(vmi, vma) {
        if (!vma_migratable(vma))
            continue;

        /* mprotect의 change_protection() 재사용! */
        change_prot_numa(vma, start, end);
        /*
         * 내부적으로:
         * change_protection(tlb, vma, start, end,
         *                   PAGE_NONE, MM_CP_PROT_NUMA);
         *
         * → change_pte_range()에서 MM_CP_PROT_NUMA 감지
         * → 이미 올바른 노드에 있는 페이지는 건너뜀
         * → 나머지는 PROT_NONE으로 설정
         */
    }
}

/* mm/memory.c - NUMA fault 핸들러 */
static vm_fault_t do_numa_page(struct vm_fault *vmf)
{
    /* 현재 CPU의 NUMA 노드 확인 */
    int cpu_nid = numa_node_id();
    int page_nid = folio_nid(folio);

    /* PTE 권한 즉시 복원 (접근 허용) */
    ptent = pte_modify(ptent, vma->vm_page_prot);

    /* 노드 불일치 시 마이그레이션 결정 */
    if (page_nid != cpu_nid) {
        migrate_misplaced_page(folio, vma, cpu_nid);
    }
}

mprotect 성능 벤치마크 코드

mprotect의 성능 특성을 실측하기 위한 마이크로 벤치마크(Microbenchmark) 코드입니다. 페이지 수별 지연 시간, MPK 대비 성능, TLB 플러시 비용을 측정합니다.

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <time.h>
#include <string.h>

static inline uint64_t rdtsc(void)
{
    uint32_t lo, hi;
    __asm__ volatile("rdtsc" : "=a"(lo), "=d"(hi));
    return ((uint64_t)hi << 32) | lo;
}

/* 페이지 수별 mprotect 지연 측정 */
void bench_mprotect_pages(int num_pages)
{
    size_t size = num_pages * 4096;
    void *mem = mmap(NULL, size, PROT_READ | PROT_WRITE,
                     MAP_PRIVATE | MAP_ANONYMOUS | MAP_POPULATE,
                     -1, 0);
    if (mem == MAP_FAILED) return;

    /* 페이지를 실제로 할당 (fault 제거) */
    memset(mem, 0, size);

    int iterations = 10000;
    uint64_t start, end, total = 0;

    for (int i = 0; i < iterations; i++) {
        start = rdtsc();
        mprotect(mem, size, PROT_READ);
        end = rdtsc();
        total += end - start;

        mprotect(mem, size, PROT_READ | PROT_WRITE);
    }

    printf("Pages: %6d | Avg cycles: %8lu | ~%.2f us (@ 3GHz)\n",
           num_pages, total / iterations,
           (total / iterations) / 3000.0);
    munmap(mem, size);
}

int main(void)
{
    printf("=== mprotect 페이지 수별 성능 벤치마크 ===\n");
    int sizes[] = {1, 4, 16, 64, 256, 1024, 4096, 16384};

    for (int i = 0; i < sizeof(sizes)/sizeof(sizes[0]); i++)
        bench_mprotect_pages(sizes[i]);

    return 0;
}

일반적인 측정 결과 (x86-64, 단일 스레드 기준):

gcc -O2 -o mprotect_bench mprotect_bench.c
taskset -c 0 ./mprotect_bench    # 단일 CPU 고정
perf stat ./mprotect_bench       # 하드웨어 카운터 병행 수집

흔한 실수와 함정

mprotect를 사용할 때 자주 발생하는 실수와 함정을 정리합니다.

1. 주소 정렬 오류

/* ❌ 잘못된 사용: 정렬되지 않은 주소 */
char *buf = malloc(4096);
mprotect(buf, 4096, PROT_READ);  /* EINVAL! malloc은 페이지 정렬 보장하지 않음 */

/* ✅ 올바른 사용: 페이지 정렬된 주소 */
void *buf = NULL;
posix_memalign(&buf, 4096, 4096);  /* 페이지 정렬 보장 */
mprotect(buf, 4096, PROT_READ);    /* OK */

/* ✅ 또는 mmap으로 직접 할당 (항상 페이지 정렬) */
void *buf = mmap(NULL, 4096, PROT_READ | PROT_WRITE,
                 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

2. 인접 데이터 부수 효과

/* ❌ 위험: 같은 페이지의 다른 데이터에 영향 */
char *page = mmap(NULL, 4096, PROT_READ | PROT_WRITE, ...);
int *important_data = (int *)(page + 0);     /* 오프셋 0 */
int *secret = (int *)(page + 2048);           /* 같은 페이지! */

/* secret만 보호하려 했지만... */
mprotect(page, 4096, PROT_READ);
*important_data = 42;  /* SIGSEGV! 같은 페이지이므로 함께 보호됨 */

/* ✅ 해결: 보호할 데이터를 별도 페이지에 배치 */
int *secret = mmap(NULL, 4096, PROT_READ | PROT_WRITE, ...);
int *data   = mmap(NULL, 4096, PROT_READ | PROT_WRITE, ...);

3. VM_MAY* 제한 무시

/* ❌ 읽기 전용 파일 매핑에 쓰기 권한 추가 시도 */
int fd = open("readonly.txt", O_RDONLY);
void *p = mmap(NULL, 4096, PROT_READ, MAP_SHARED, fd, 0);
mprotect(p, 4096, PROT_READ | PROT_WRITE);
/* → EACCES: VM_MAYWRITE가 없으므로 실패 */

/* ✅ 해결: MAP_PRIVATE로 매핑하면 VM_MAYWRITE 설정됨 */
void *p = mmap(NULL, 4096, PROT_READ, MAP_PRIVATE, fd, 0);
mprotect(p, 4096, PROT_READ | PROT_WRITE);  /* OK (COW 적용) */

4. VMA 단편화 폭발

/* ❌ 위험: 페이지마다 다른 보호 → VMA 폭발 */
void *region = mmap(NULL, 1024 * 4096, PROT_READ | PROT_WRITE, ...);
for (int i = 0; i < 1024; i += 2) {
    /* 짝수 페이지만 PROT_READ → 512개의 VMA 분할! */
    mprotect(region + i * 4096, 4096, PROT_READ);
}
/* → /proc/PID/maps에 1024개 VMA 생성 가능
 * → vm.max_map_count (기본 65530) 초과 위험
 * → find_vma() 성능 저하 */

/* ✅ 해결: 연속된 영역을 한 번에 변경하거나 MPK 사용 */

5. THP split 미인지

/* ❌ THP 영역의 부분 mprotect → huge page split */
void *p = mmap(NULL, 2 * 1024 * 1024, PROT_READ | PROT_WRITE,
               MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
/* 커널이 THP로 2MB 매핑할 수 있음 */

mprotect(p + 4096, 4096, PROT_READ);
/* → 2MB THP가 512개의 4KB 페이지로 분할!
 * → TLB miss 증가, 메모리 단편화 */

/* ✅ 해결: THP 경계에 맞춰 mprotect 호출 */
mprotect(p, 2 * 1024 * 1024, PROT_READ);  /* 전체 2MB → split 불필요 */

6. SELinux execmem 차단

# JIT 컴파일러가 EACCES로 실패할 때
# audit 로그 확인
$ ausearch -m AVC -ts recent | grep mprotect
type=AVC msg=audit(...): avc:  denied  { execmem } for  pid=1234 ...

# 임시 해결 (프로덕션에서는 정책 수정 권장)
$ setsebool -P allow_execmem 1

# 영구 해결: 해당 도메인에만 execmem 허용
# allow myapp_t self:process execmem;

mprotect 관련 /proc 인터페이스

mprotect 동작의 결과와 영향을 관찰하기 위한 /proc 파일시스템 인터페이스를 정리합니다.

# 1. /proc/PID/maps - VMA별 보호 속성 확인
$ cat /proc/self/maps
# 주소범위              권한  오프셋   디바이스 inode  경로
# 7f8a12000000-7f8a12400000 r-xp 00000000 fd:01 12345  /usr/lib/libc.so.6
#                            ^^^^
#                            r = 읽기, - = 쓰기없음, x = 실행, p = private

# 2. /proc/PID/smaps - VMA 상세 정보 + VmFlags
$ grep -A 20 "7f8a12000000" /proc/self/smaps
# VmFlags: rd ex mr mw me sd
#   rd = VM_READ        mr = VM_MAYREAD
#   -- = VM_WRITE 없음  mw = VM_MAYWRITE  ← mprotect로 쓰기 추가 가능!
#   ex = VM_EXEC        me = VM_MAYEXEC
#   sd = VM_SOFTDIRTY

# 3. /proc/PID/pagemap - 물리 주소 + soft-dirty 비트
# bit 55: soft-dirty (mprotect 후 clear_refs로 추적)
$ echo 4 > /proc/self/clear_refs  # soft-dirty 비트 초기화
# → 이후 쓰기된 페이지만 soft-dirty=1

# 4. VMA 수 모니터링
$ wc -l /proc/self/maps           # 현재 VMA 수
$ cat /proc/sys/vm/max_map_count  # 최대 허용 VMA 수 (기본 65530)

# 5. NUMA 밸런싱 상태 확인
$ cat /proc/sys/kernel/numa_balancing        # 0=비활성, 1=활성
$ cat /proc/vmstat | grep numa               # NUMA 페이지 마이그레이션 통계
# numa_hit        12345   ← 로컬 노드 할당 성공
# numa_miss       678     ← 원격 노드에서 할당
# numa_pages_migrated 90  ← AutoNUMA 마이그레이션 횟수

# 6. MPK(PKRU) 상태 확인
$ cat /proc/self/arch_status
# PKRU: 0x55555554
#   각 2비트가 하나의 pkey: [AD WD] [AD WD] ...
#   0x55555554 = 0101...0100 → pkey 0만 접근 허용, 나머지 쓰기 금지

참고자료

• mprotect(2) - Linux man page
• pkey_mprotect(2) - Linux man page
• pkeys(7) - Memory Protection Keys 개요
• Linux Kernel Documentation - Memory Protection Keys
• mm/mprotect.c - 커널 소스 (Bootlin Elixir)
• LWN.net - Memory protection keys
• Intel SDM - Protection Keys (Volume 3, Chapter 4)
• mmap(2) — 메모리 보호 플래그 (PROT_READ, PROT_WRITE, PROT_EXEC)
• LWN: Memory sealing (2022) — 메모리 영역 보호 변경을 방지하는 봉인 메커니즘을 다룹니다
• arch/x86/mm/pkeys.c — x86 PKU(Protection Keys for Userspace) 구현 소스입니다
• Memory Protection Keys — Linux Kernel Documentation