# mremap 🔄

관련 소스: mm/mremap.c, mm/internal.h, include/uapi/linux/mman.h

개요 (Overview)

mremap()는 기존 가상 메모리 영역(VMA)의 크기를 변경하거나 다른 가상 주소로 이동하는 시스템 호출입니다. 이 시스템 호출은 메모리 매핑의 확장, 축소, 이동을 모두 처리하며, 리눅스 커널의 메모리 관리 서브시스템에서 중요한 역할을 합니다.

일상 비유: mremap()는 아파트를 리모델링하는 것과 같습니다. 방의 크기를 키우거나(확장), 줄이거나(축소), 아예 다른 층으로 옮기는(이동) 것과 비슷합니다. 커널은 이 작업을 수행할 때 페이지 테이블을 조정하여 프로세스가 계속해서 동일한 가상 주소를 사용할 수 있도록 합니다.

mremap()는 세 가지 기본 연산을 지원합니다: in-place 확장(in-place expansion), in-place 축소(in-place shrinking), 그리고 VMA 이동(VMA moving). 각 연산은 서로 다른 시나리오에서 사용되며, 커널은 최적의 방법을 자동으로 선택합니다.

소스 파일 경로:

mm/mremap.c          # 메인 구현 (1998줄)
mm/internal.h        # pagetable_move_control 구조체 정의
include/uapi/linux/mman.h  # MREMAP 플래그 정의

mremap 호출 흐름

mremap 핵심 자료구조 관계도

---

빠른 점검 명령

# 1. mremap 시스템 호출 호출 횟수 확인
cat /proc/kstat | grep mremap

# 2. 현재 프로세스의 VMA 맵 확인
cat /proc/self/maps | head -20

# 3. mremap 관련 커널 통계 확인
cat /proc/vmstat | grep -i mremap

# 4. mremap 실패 횟수 확인 (dmesg에서)
dmesg | grep -i "mremap" | tail -10

# 5. 특정 프로세스의 VMA 변경 추적
strace -e mremap <프로세스명>

# 6. mremap 플래그 확인
grep -r "MREMAP_" /usr/include/linux/mman.h

# 7. 커널 mremap 관련 모듈 확인
lsmod | grep -i mremap

# 8. mremap 관련 커널 파라미터 확인
sysctl -a | grep -i mremap

# 9. mremap 호출 시 VMA 변경 추적
perf trace -e mremap <프로세스명>

# 10. mremap 관련 커널 로그 확인
journalctl -k | grep -i mremap

# 11. VMA 맵 수 확인 (mremap 실패 원인 진단)
cat /proc/self/status | grep -i vmsize

# 12. 메모리 매핑 통계 확인
cat /proc/vmstat | grep -i mmap

# 13. 페이지 테이블 통계 확인
cat /proc/vmstat | grep -i pte

# 14. TLB 플러시 통계 확인
cat /proc/vmstat | grep -i tlb

---

핵심 자료구조

1. vma_remap_struct

mremap() 연산 전체를 설명하는 메인 구조체입니다.

/* mm/mremap.c:50-73 */
struct vma_remap_struct {
/* 사용자 제공 상태 */
unsigned long addr;      /* 리매핑할 원본 가상 주소 */
unsigned long old_len;   /* 리매핑할 범위의 기존 길이 */
unsigned long new_len;   /* 원하는 새 길이 */
const unsigned long flags; /* MREMAP_* 플래그 */
unsigned long new_addr;  /* 선택적 새 주소 */

/* uffd 상태 */
struct vm_userfaultfd_ctx *uf;
struct list_head *uf_unmap_early;
struct list_head *uf_unmap;

/* VMA 상태 - do_mremap()에서 결정 */
struct vm_area_struct *vma;

/* 내부 상태 - do_mremap()에서 결정 */
unsigned long delta;     /* old_len과 new_len의 절대 차이 */
bool populate_expand;    /* mlock()된 확장 영역, populate 필요 */
enum mremap_type remap_type; /* expand, shrink 등 */
bool mmap_locked;        /* 현재 mm이 쓰기 잠금 상태인지 */
unsigned long charged;   /* VM_ACCOUNT인 경우, 청구할 페이지 수 */
bool vmi_needs_invalidate; /* VMA 반복자가 무효화되었는지 */
};

2. pagetable_move_control

페이지 테이블 이동 연산을 제어하는 구조체입니다.

/* mm/internal.h:46-56 */
struct pagetable_move_control {
struct vm_area_struct *old; /* 소스 VMA */
struct vm_area_struct *new; /* 대상 VMA */
unsigned long old_addr;     /* 이동이 시작되는 주소 */
unsigned long old_end;      /* 기존 범위가 끝나는 주소 (포함되지 않음) */
unsigned long new_addr;     /* 페이지 테이블을 이동할 주소 */
unsigned long len_in;       /* 사용자가 지정한 리매핑할 바이트 수 */

bool need_rmap_locks;       /* rmap 잠금이 필요한지 */
bool for_stack;             /* 초기 임시 스택을 이동 중인지 */
};

/* PAGETABLE_MOVE 매크로로 초기화 */
/* mm/internal.h:58-66 */
#define PAGETABLE_MOVE(name, old_, new_, old_addr_, new_addr_, len_)    \
struct pagetable_move_control name = {                             \
.old = old_,                                                   \
.new = new_,                                                   \
.old_addr = old_addr_,                                         \
.old_end = (old_addr_) + (len_),                               \
.new_addr = new_addr_,                                         \
.len_in = len_,                                                \
}

3. mremap_type 열거형

리매핑 연산 유형을 분류합니다.

/* mm/mremap.c:36-41 */
enum mremap_type {
MREMAP_INVALID,    /* 초기 상태 */
MREMAP_NO_RESIZE,  /* old_len == new_len, 이동하지 않으면 아무것도 하지 않음 */
MREMAP_SHRINK,     /* old_len > new_len */
MREMAP_EXPAND,     /* old_len < new_len */
};

4. MREMAP 플래그

/* include/uapi/linux/mman.h:9-11 */
#define MREMAP_MAYMOVE    1  /* 이동 허용 */
#define MREMAP_FIXED      2  /* 고정 주소로 이동 */
#define MREMAP_DONTUNMAP  4  /* 원본 매핑 유지 (복사 후 이동) */

MREMAP_MAYMOVE: mremap가 새 주소에서 매핑을 허용합니다. in-place 확장/축소가 불가능할 때 이동이 필요합니다.

MREMAP_FIXED: 지정된 주소(new_addr)로 이동합니다. 기존 매핑이 있으면 먼저 제거됩니다. MREMAP_MAYMOVE가 함께 설정되어야 합니다.

MREMAP_DONTUNMAP: 원본 매핑을 유지하면서 새 위치에 복사합니다. 프로세스 간 공유 메모리 복사에 사용됩니다.

---

핵심 함수

1. SYSCALL_DEFINE5(mremap)

mremap() 시스템 호출의 진입점입니다.

/* mm/mremap.c:1965-1998 */
SYSCALL_DEFINE5(mremap, unsigned long, addr, unsigned long, old_len,
unsigned long, new_len, unsigned long, flags,
unsigned long, new_addr)
{
struct vm_userfaultfd_ctx uf = NULL_VM_UFFD_CTX;
LIST_HEAD(uf_unmap_early);
LIST_HEAD(uf_unmap);
struct vma_remap_struct vrm = {
.addr = untagged_addr(addr),  /* ARM64 태그 제거 */
.old_len = old_len,
.new_len = new_len,
.flags = flags,
.new_addr = new_addr,
.uf = &uf,
.uf_unmap_early = &uf_unmap_early,
.uf_unmap = &uf_unmap,
.remap_type = MREMAP_INVALID,
};
return do_mremap(&vrm);
}

역할: 사용자 공간에서 전달된 파라미터를 검증하고 vma_remap_struct를 초기화한 후 do_mremap()를 호출합니다. ARM64 태그 주소 처리를 위해 untagged_addr()을 사용합니다.

2. do_mremap

mremap의 메인 로직을 수행하는 함수입니다.

/* mm/mremap.c:1915-1956 */
static unsigned long do_mremap(struct vma_remap_struct *vrm)
{
struct mm_struct *mm = current->mm;
unsigned long res;
bool failed;

/* 길이를 페이지 크기에 정렬 */
vrm->old_len = PAGE_ALIGN(vrm->old_len);
vrm->new_len = PAGE_ALIGN(vrm->new_len);

/* 파라미터 검증 */
res = check_mremap_params(vrm);
if (res)
return res;

/* mmap 쓰기 잠금 획득 */
if (mmap_write_lock_killable(mm))
return -EINTR;
vrm->mmap_locked = true;

/* 이동만 하는 경우 */
if (vrm_move_only(vrm)) {
res = remap_move(vrm);
} else {
/* VMA 조회 및 검증 */
vrm->vma = vma_lookup(current->mm, vrm->addr);
res = check_prep_vma(vrm);
if (res)
goto out;

/* mremap 실행 */
res = vrm_implies_new_addr(vrm) ? mremap_to(vrm) : mremap_at(vrm);
}

out:
failed = IS_ERR_VALUE(res);
if (vrm->mmap_locked)
mmap_write_unlock(mm);

/* mlock된 확장 영역 populate */
if (!failed && vrm->populate_expand)
mm_populate(vrm->new_addr + vrm->old_len, vrm->delta);

/* userfaultfd 알림 */
notify_uffd(vrm, failed);
return res;
}

역할: 페이지 정렬된 길이를 계산하고, 파라미터를 검증한 후, mmap 잠금을 획득합니다. 그 다음 이동 전용 경로 또는 일반 경로를 선택하여 실행합니다.

3. check_mremap_params

mremap 파라미터의 유효성을 검증하는 함수입니다.

/* mm/mremap.c:1756-1824 */
static unsigned long check_mremap_params(struct vma_remap_struct *vrm)
{
unsigned long addr = vrm->addr;
unsigned long flags = vrm->flags;

/* 예상치 못한 플래그 값 방지 */
if (flags & ~(MREMAP_FIXED | MREMAP_MAYMOVE | MREMAP_DONTUNMAP))
return -EINVAL;

/* 시작 주소는 페이지 정렬어야 함 */
if (offset_in_page(addr))
return -EINVAL;

/* new_len이 0이면 안됨 */
if (!vrm->new_len)
return -EINVAL;

/* new_len이 TASK_SIZE를 초과하면 안됨 */
if (vrm->new_len > TASK_SIZE)
return -EINVAL;

/* 고정 주소 지정 시 추가 검증 */
if (!vrm_implies_new_addr(vrm))
return 0;

/* new_addr이 TASK_SIZE - new_len을 초과하면 안됨 */
if (vrm->new_addr > TASK_SIZE - vrm->new_len)
return -EINVAL;

/* new_addr은 페이지 정렬어야 함 */
if (offset_in_page(vrm->new_addr))
return -EINVAL;

/* 고정 주소는 MREMAP_MAYMOVE 필요 */
if (!(flags & MREMAP_MAYMOVE))
return -EINVAL;

/* MREMAP_DONTUNMAP은 크기 변경 불가 */
if (flags & MREMAP_DONTUNMAP && vrm->old_len != vrm->new_len)
return -EINVAL;

/* 대상 VMA와 소스 VMA가 겹치면 안됨 */
if (vrm_overlaps(vrm))
return -EINVAL;

/* VMA 맵 수 제한 확인 */
if ((current->mm->map_count + 2) >= sysctl_max_map_count - 3)
return -ENOMEM;

return 0;
}

역할: 플래그 유효성, 주소 정렬, 크기 제한, VMA 겹침 등을 검증합니다.

4. check_prep_vma

VMA 이동 전 준비 검증을 수행하는 함수입니다.

/* mm/mremap.c:1655-1750 */
static int check_prep_vma(struct vma_remap_struct *vrm)
{
struct vm_area_struct *vma = vrm->vma;
struct mm_struct *mm = current->mm;
unsigned long addr = vrm->addr;
unsigned long old_len, new_len, pgoff;

if (!vma)
return -EFAULT;

/* mseal()된 VMA는 mremap 불가 */
if (vma_is_sealed(vma))
return -EPERM;

/* HugeTLB 페이지는 정렬 필요 */
if (is_vm_hugetlb_page(vma) && !align_hugetlb(vrm))
return -EINVAL;

vrm_set_delta(vrm);
vrm->remap_type = vrm_remap_type(vrm);

/* 새 주소가 필요한 경우 */
if (!vrm_implies_new_addr(vrm))
vrm->new_addr = addr;

if (!vrm_will_map_new(vrm))
return 0;

old_len = vrm->old_len;
new_len = vrm->new_len;

/* 비공유 매핑의 경우 old_len=0 허용 안됨 */
if (!old_len && !(vma->vm_flags & (VM_SHARED | VM_MAYSHARE))) {
pr_warn_once("%s (%d): attempted to duplicate a private mapping with mremap. This is not supported.\n",
current->comm, current->pid);
return -EINVAL;
}

/* MREMAP_DONTUNMAP은 VM_DONTEXPAND/VM_PFNMAP 불가 */
if ((vrm->flags & MREMAP_DONTUNMAP) &&
(vma->vm_flags & (VM_DONTEXPAND | VM_PFNMAP)))
return -EINVAL;

/* 축소 시 old_len 조정 */
if (vrm->remap_type == MREMAP_SHRINK)
old_len = new_len;

/* old_len이 VMA 범위를 초과하면 안됨 */
if (old_len > vma->vm_end - addr)
return -EFAULT;

if (new_len == old_len)
return 0;

/* mlock된 VMA 확장 시 populate 필요 */
if (vma->vm_flags & VM_LOCKED)
vrm->populate_expand = true;

/* 페이지 오버플로우 검사 */
pgoff = (addr - vma->vm_start) >> PAGE_SHIFT;
pgoff += vma->vm_pgoff;
if (pgoff + (new_len >> PAGE_SHIFT) < pgoff)
return -EINVAL;

/* VM_DONTEXPAND/VM_PFNMAP는 확장 불가 */
if (vma->vm_flags & (VM_DONTEXPAND | VM_PFNMAP))
return -EFAULT;

if (!mlock_future_ok(mm, vma->vm_flags & VM_LOCKED, vrm->delta))
return -EAGAIN;

if (!may_expand_vm(mm, vma->vm_flags, vrm->delta >> PAGE_SHIFT))
return -ENOMEM;

return 0;
}

역할: VMA 상태, mseal, HugeTLB 정렬, 확장 가능성을 검증합니다.

5. move_vma

VMA를 새 위치로 이동하는 핵심 함수입니다.

/* mm/mremap.c:1270-1321 */
static unsigned long move_vma(struct vma_remap_struct *vrm)
{
struct mm_struct *mm = current->mm;
struct vm_area_struct *new_vma;
unsigned long hiwater_vm;
int err;

/* 이동 전 준비 */
err = prep_move_vma(vrm);
if (err)
return err;

/* 계정 처리 */
if (!vrm_calc_charge(vrm))
return -ENOMEM;

/* VMA 쓰기 잠금 획득 */
vma_start_write(vrm->vma);

/* 복사 단계 수행 */
err = copy_vma_and_data(vrm, &new_vma);
if (err && !new_vma)
return err;

/* 통계 계정 */
hiwater_vm = mm->hiwater_vm;
vrm_stat_account(vrm, vrm->new_len);

/* 원본 VMA 처리 */
if (unlikely(!err && (vrm->flags & MREMAP_DONTUNMAP)))
dontunmap_complete(vrm, new_vma);
else
unmap_source_vma(vrm);

mm->hiwater_vm = hiwater_vm;
return err ? (unsigned long)err : vrm->new_addr;
}

역할: VMA를 새 위치로 복사하고, 페이지 테이블을 이동한 후, 원본 VMA를 처리합니다. MREMAP_DONTUNMAP 플래그가 설정된 경우 원본을 유지합니다.

6. move_page_tables

페이지 테이블을 실제 이동하는 함수입니다.

/* mm/mremap.c:795-879 */
unsigned long move_page_tables(struct pagetable_move_control *pmc)
{
unsigned long extent;
struct mmu_notifier_range range;
pmd_t *old_pmd, *new_pmd;
pud_t *old_pud, *new_pud;
struct mm_struct *mm = pmc->old->vm_mm;

if (!pmc->len_in)
return 0;

/* HugeTLB 페이지의 경우 별도 처리 */
if (is_vm_hugetlb_page(pmc->old))
return move_hugetlb_page_tables(pmc->old, pmc->new, pmc->old_addr,
pmc->new_addr, pmc->len_in);

/* PMD 경계에 정렬하여 성능 향상 */
try_realign_addr(pmc, PMD_MASK);

/* 캐시 플러시 및 MMU 알림 시작 */
flush_cache_range(pmc->old, pmc->old_addr, pmc->old_end);
mmu_notifier_range_init(&range, MMU_NOTIFY_UNMAP, 0, mm,
pmc->old_addr, pmc->old_end);
mmu_notifier_invalidate_range_start(&range);

/* 페이지 테이블 순회 및 이동 */
for (; !pmc_done(pmc); pmc_next(pmc, extent)) {
cond_resched();

/* PUD 레벨 이동 시도 */
extent = get_extent(NORMAL_PUD, pmc);
old_pud = get_old_pud(mm, pmc->old_addr);
if (!old_pud)
continue;
new_pud = alloc_new_pud(mm, pmc->new_addr);
if (!new_pud)
break;

/* Huge PUD 이동 */
if (pud_trans_huge(*old_pud)) {
if (extent == HPAGE_PUD_SIZE) {
move_pgt_entry(pmc, HPAGE_PUD, old_pud, new_pud);
continue;
}
} else if (IS_ENABLED(CONFIG_HAVE_MOVE_PUD) && extent == PUD_SIZE) {
if (move_pgt_entry(pmc, NORMAL_PUD, old_pud, new_pud))
continue;
}

/* PMD 레벨 이동 시도 */
extent = get_extent(NORMAL_PMD, pmc);
old_pmd = get_old_pmd(mm, pmc->old_addr);
if (!old_pmd)
continue;
new_pmd = alloc_new_pmd(mm, pmc->new_addr);
if (!new_pmd)
break;

/* Huge PMD 이동 */
if (pmd_is_huge(*old_pmd)) {
if (extent == HPAGE_PMD_SIZE &&
move_pgt_entry(pmc, HPAGE_PMD, old_pmd, new_pmd))
continue;
split_huge_pmd(pmc->old, old_pmd, pmc->old_addr);
} else if (IS_ENABLED(CONFIG_HAVE_MOVE_PMD) && extent == PMD_SIZE) {
if (move_pgt_entry(pmc, NORMAL_PMD, old_pmd, new_pmd))
continue;
}

/* PTE 레벨 이동 */
if (pmd_none(*old_pmd))
continue;
if (pte_alloc(pmc->new->vm_mm, new_pmd))
break;
if (move_ptes(pmc, extent, old_pmd, new_pmd) < 0)
goto again;
}

mmu_notifier_invalidate_range_end(&range);
return pmc_progress(pmc);
}

역할: 페이지 테이블 계층(PUD→PMD→PTE)을 순회하면서 각 엔트리를 새 위치로 이동합니다. Huge 페이지와 일반 페이지를 구분하여 처리하며, rmap 잠금을 관리합니다.

7. move_ptes

개별 PTE를 이동하는 함수입니다.

/* mm/mremap.c:197-319 */
static int move_ptes(struct pagetable_move_control *pmc,
unsigned long extent, pmd_t *old_pmd, pmd_t *new_pmd)
{
struct vm_area_struct *vma = pmc->old;
bool need_clear_uffd_wp = vma_has_uffd_without_event_remap(vma);
struct mm_struct *mm = vma->vm_mm;
pte_t *old_ptep, *new_ptep;
pte_t old_pte, pte;
pmd_t dummy_pmdval;
spinlock_t *old_ptl, *new_ptl;
bool force_flush = false;
unsigned long old_addr = pmc->old_addr;
unsigned long new_addr = pmc->new_addr;
unsigned long old_end = old_addr + extent;
unsigned long len = old_end - old_addr;
int max_nr_ptes;
int nr_ptes;
int err = 0;

/* rmap 잠금 필요시 획득 */
if (pmc->need_rmap_locks)
take_rmap_locks(vma);

/* 소스 PTE 잠금 */
old_ptep = pte_offset_map_lock(mm, old_pmd, old_addr, &old_ptl);
if (!old_ptep) {
err = -EAGAIN;
goto out;
}

/* 대상 PTE 매핑 */
new_ptep = pte_offset_map_rw_nolock(mm, new_pmd, new_addr, &dummy_pmdval,
&new_ptl);
if (!new_ptep) {
pte_unmap_unlock(old_ptep, old_ptl);
err = -EAGAIN;
goto out;
}

/* 중첩 잠금 처리 */
if (new_ptl != old_ptl)
spin_lock_nested(new_ptl, SINGLE_DEPTH_NESTING);
flush_tlb_batched_pending(vma->vm_mm);
lazy_mmu_mode_enable();

/* PTE 순회 및 이동 */
for (; old_addr < old_end; old_ptep += nr_ptes, old_addr += nr_ptes * PAGE_SIZE,
new_ptep += nr_ptes, new_addr += nr_ptes * PAGE_SIZE) {
VM_WARN_ON_ONCE(!pte_none(*new_ptep));

nr_ptes = 1;
max_nr_ptes = (old_end - old_addr) >> PAGE_SHIFT;
old_pte = ptep_get(old_ptep);
if (pte_none(old_pte))
continue;

/* 유효한 PTE인 경우 TLB 플러시 필요 */
if (pte_present(old_pte)) {
nr_ptes = mremap_folio_pte_batch(vma, old_addr, old_ptep,
old_pte, max_nr_ptes);
force_flush = true;
}

/* PTE 이동 */
pte = get_and_clear_ptes(mm, old_addr, old_ptep, nr_ptes);
pte = move_pte(pte, old_addr, new_addr);
pte = move_soft_dirty_pte(pte);

/* uffd-wp 처리 */
if (need_clear_uffd_wp && pte_is_uffd_wp_marker(pte))
pte_clear(mm, new_addr, new_ptep);
else {
if (need_clear_uffd_wp) {
if (pte_present(pte))
pte = pte_clear_uffd_wp(pte);
else
pte = pte_swp_clear_uffd_wp(pte);
}
set_ptes(mm, new_addr, new_ptep, pte, nr_ptes);
}
}

lazy_mmu_mode_disable();
if (force_flush)
flush_tlb_range(vma, old_end - len, old_end);
if (new_ptl != old_ptl)
spin_unlock(new_ptl);
pte_unmap(new_ptep - 1);
pte_unmap_unlock(old_ptep - 1, old_ptl);
out:
if (pmc->need_rmap_locks)
drop_rmap_locks(vma);
return err;
}

역할: 개별 PTE를 소스에서 대상으로 이동합니다. folio 배치 처리, soft-dirty 비트 처리, userfaultfd-wp 처리를 수행합니다.

8. mremap_folio_pte_batch

large folio의 경우 여러 PTE를 한 번에 배치 처리하는 함수입니다.

/* mm/mremap.c:178-195 */
static int mremap_folio_pte_batch(struct vm_area_struct *vma, unsigned long addr,
pte_t *ptep, pte_t pte, int max_nr)
{
struct folio *folio;

if (max_nr == 1)
return 1;

/* large folio가 아니면 배치 불가 */
if (pte_batch_hint(ptep, pte) == 1)
return 1;

folio = vm_normal_folio(vma, addr, pte);
if (!folio || !folio_test_large(folio))
return 1;

return folio_pte_batch_flags(folio, NULL, ptep, &pte, max_nr, FPB_RESPECT_WRITE);
}

역할: large folio의 경우 여러 PTE를 한 번에 처리하여 성능을 향상시킵니다.

9. move_soft_dirty_pte

soft-dirty 비트를 설정하는 함수입니다.

/* mm/mremap.c:159-176 */
static pte_t move_soft_dirty_pte(pte_t pte)
{
if (pte_none(pte))
return pte;

/* soft dirty 비트 설정하여 사용자 공간에서 PTE 이동 감지 */
if (pgtable_supports_soft_dirty()) {
if (pte_present(pte))
pte = pte_mksoft_dirty(pte);
else
pte = pte_swp_mksoft_dirty(pte);
}

return pte;
}

역할: PTE가 이동되었음을 사용자 공간에서 감지할 수 있도록 soft-dirty 비트를 설정합니다.

10. mremap_to

지정된 주소로 VMA를 리매핑하는 함수입니다.

/* mm/mremap.c:1367-1417 */
static unsigned long mremap_to(struct vma_remap_struct *vrm)
{
struct mm_struct *mm = current->mm;
unsigned long err;

/* MREMAP_FIXED인 경우 대상 영역 먼저 제거 */
if (vrm->flags & MREMAP_FIXED) {
err = do_munmap(mm, vrm->new_addr, vrm->new_len,
vrm->uf_unmap_early);
vrm->vma = NULL;
vrm->vmi_needs_invalidate = true;
if (err)
return err;

/* VMA 재조회 */
vrm->vma = vma_lookup(mm, vrm->addr);
if (!vrm->vma)
return -EFAULT;
}

/* 축소 처리 */
if (vrm->remap_type == MREMAP_SHRINK) {
err = shrink_vma(vrm, false);
if (err)
return err;

vrm->old_len = vrm->new_len;
}

/* MREMAP_DONTUNMAP은 확장 검증 */
if (vrm->flags & MREMAP_DONTUNMAP) {
vm_flags_t vm_flags = vrm->vma->vm_flags;
unsigned long pages = vrm->old_len >> PAGE_SHIFT;

if (!may_expand_vm(mm, vm_flags, pages))
return -ENOMEM;
}

/* 새 주소 결정 */
err = vrm_set_new_addr(vrm);
if (err)
return err;

return move_vma(vrm);
}

역할: MREMAP_FIXED 플래그로 지정된 주소로 VMA를 이동합니다.

11. mremap_at

주소 지정 없이 VMA 크기를 변경하는 함수입니다.

/* mm/mremap.c:1554-1584 */
static unsigned long mremap_at(struct vma_remap_struct *vrm)
{
unsigned long res;

switch (vrm->remap_type) {
case MREMAP_INVALID:
break;
case MREMAP_NO_RESIZE:
/* 크기 변경 없음 - no-op */
return vrm->addr;
case MREMAP_SHRINK:
/* 축소 - 항상 in-place 가능 */
res = shrink_vma(vrm, true);
if (res)
return res;

return vrm->addr;
case MREMAP_EXPAND:
return expand_vma(vrm);
}

WARN_ON_ONCE(1);
return -EINVAL;
}

역할: MREMAP_NO_RESIZE, MREMAP_SHRINK, MREMAP_EXPAND 유형에 따라 적절한 처리를 수행합니다.

12. expand_vma

VMA를 확장하는 함수입니다.

/* mm/mremap.c:1516-1548 */
static unsigned long expand_vma(struct vma_remap_struct *vrm)
{
unsigned long err;

/* in-place 확장 가능 여부 확인 */
if (vrm_can_expand_in_place(vrm)) {
err = expand_vma_in_place(vrm);
if (err)
return err;

return vrm->addr;
}

/* in-place 확장 불가능하면 이동 필요 */
if (!(vrm->flags & MREMAP_MAYMOVE))
return -ENOMEM;

/* 새 주소 결정 */
err = vrm_set_new_addr(vrm);
if (err)
return err;

return move_vma(vrm);
}

역할: in-place 확장을 시도하고, 불가능하면 MREMAP_MAYMOVE 플래그가 설정된 경우 이동을 수행합니다.

13. expand_vma_in_place

VMA를 in-place로 확장하는 함수입니다.

/* mm/mremap.c:1456-1484 */
static unsigned long expand_vma_in_place(struct vma_remap_struct *vrm)
{
struct mm_struct *mm = current->mm;
struct vm_area_struct *vma = vrm->vma;
VMA_ITERATOR(vmi, mm, vma->vm_end);

/* 계정 처리 */
if (!vrm_calc_charge(vrm))
return -ENOMEM;

/* VMA 확장 및 병합 */
vma = vma_merge_extend(&vmi, vma, vrm->delta);
if (!vma) {
vrm_uncharge(vrm);
return -ENOMEM;
}
vrm->vma = vma;

/* 통계 계정 */
vrm_stat_account(vrm, vrm->delta);

return 0;
}

역할: VMA를 in-place로 확장하고, 인접 VMA와 병합을 시도합니다.

14. shrink_vma

VMA를 축소하는 함수입니다.

/* mm/mremap.c:1330-1361 */
static unsigned long shrink_vma(struct vma_remap_struct *vrm,
bool drop_lock)
{
struct mm_struct *mm = current->mm;
unsigned long unmap_start = vrm->addr + vrm->new_len;
unsigned long unmap_bytes = vrm->delta;
unsigned long res;
VMA_ITERATOR(vmi, mm, unmap_start);

VM_BUG_ON(vrm->remap_type != MREMAP_SHRINK);

/* 축소 영역 제거 */
res = do_vmi_munmap(&vmi, mm, unmap_start, unmap_bytes,
vrm->uf_unmap, drop_lock);
vrm->vma = NULL;
if (res)
return res;

/* 잠금 해제 시 VMA 재조회 */
if (drop_lock) {
vrm->mmap_locked = false;
} else {
vrm->vma = vma_lookup(mm, vrm->addr);
if (!vrm->vma)
return -EFAULT;
}

return 0;
}

역할: VMA의 끝부분을 제거하여 크기를 축소합니다.

15. remap_move

여러 VMA를 한 번에 이동하는 함수입니다.

/* mm/mremap.c:1826-1913 */
static unsigned long remap_move(struct vma_remap_struct *vrm)
{
struct vm_area_struct *vma;
unsigned long start = vrm->addr;
unsigned long end = vrm->addr + vrm->old_len;
unsigned long new_addr = vrm->new_addr;
unsigned long target_addr = new_addr;
unsigned long res = -EFAULT;
unsigned long last_end;
bool seen_vma = false;

VMA_ITERATOR(vmi, current->mm, start);

/* 범위 내 모든 VMA 순회 */
for_each_vma_range(vmi, vma, end) {
unsigned long addr = max(vma->vm_start, start);
unsigned long len = min(end, vma->vm_end) - addr;
unsigned long offset, res_vma;
bool multi_allowed;

/* 시작 부분의 간격 허용 안됨 */
if (!seen_vma && start < vma->vm_start)
return -EFAULT;

/* 간격 유지하여 이동 */
offset = seen_vma ? vma->vm_start - last_end : 0;
last_end = vma->vm_end;

vrm->vma = vma;
vrm->addr = addr;
vrm->new_addr = target_addr + offset;
vrm->old_len = vrm->new_len = len;

multi_allowed = vma_multi_allowed(vma);
if (!multi_allowed) {
if (seen_vma)
return -EFAULT;
if (vma->vm_end < end)
return -EFAULT;
}

res_vma = check_prep_vma(vrm);
if (!res_vma)
res_vma = mremap_to(vrm);
if (IS_ERR_VALUE(res_vma))
return res_vma;

if (!seen_vma) {
VM_WARN_ON_ONCE(multi_allowed && res_vma != new_addr);
res = res_vma;
}

if (vrm->vmi_needs_invalidate) {
vma_iter_invalidate(&vmi);
vrm->vmi_needs_invalidate = false;
}
seen_vma = true;
target_addr = res_vma + vrm->new_len;
}

return res;
}

역할: 여러 VMA를 한 번에 이동할 때 간격을 유지하면서 병렬로 처리합니다.

---

호출 흐름

SYSCALL_DEFINE5(mremap)  ← 사용자 시스템 호출 진입점
↓
do_mremap()  ← 메인 로직 처리
├─ check_mremap_params()  # 파라미터 검증 (플래그, 주소, 크기)
├─ mmap_write_lock_killable()  # mmap 쓰기 잠금 획득
├─ vrm_move_only()?
│   ├─ YES → remap_move()  # 다중 VMA 이동 (간격 유지)
│   │         └─ for_each_vma_range()
│   │             ├─ check_prep_vma()  # VMA 준비 검증
│   │             └─ mremap_to()  # 지정 주소로 이동
│   │                 ├─ do_munmap()  # 대상 영역 제거
│   │                 ├─ vrm_set_new_addr()  # 새 주소 결정
│   │                 └─ move_vma()
│   │                     ├─ prep_move_vma()  # VMA 분할 준비
│   │                     ├─ vrm_calc_charge()  # 계정 처리
│   │                     ├─ copy_vma_and_data()
│   │                     │   ├─ copy_vma()  # VMA 복사
│   │                     │   └─ move_page_tables()  # 페이지 테이블 이동
│   │                     │       ├─ try_realign_addr()  # PMD 경계 정렬
│   │                     │       ├─ move_pgt_entry()  # PUD/PMD 레벨 이동
│   │                     │       └─ move_ptes()  # PTE 레벨 이동
│   │                     │           └─ mremap_folio_pte_batch()  # large folio 배치
│   │                     ├─ vrm_stat_account()  # 통계 계정
│   │                     └─ unmap_source_vma()  # 원본 제거
│   └─ NO → vma_lookup()  # VMA 조회
│           ├─ check_prep_vma()  # VMA 준비 검증
│           └─ mremap_to() 또는 mremap_at()
│               ├─ mremap_to()  # 고정 주소로 이동
│               │   ├─ do_munmap()  # 대상 영역 제거
│               │   ├─ shrink_vma()  # 축소 처리
│               │   └─ move_vma()
│               └─ mremap_at()  # 주소 지정 없이 이동
│                   ├─ MREMAP_NO_RESIZE → 즉시 반환
│                   ├─ MREMAP_SHRINK → shrink_vma()
│                   └─ MREMAP_EXPAND → expand_vma()
│                       ├─ vrm_can_expand_in_place()?
│                       │   ├─ YES → expand_vma_in_place()
│                       │   │         └─ vma_merge_extend()
│                       │   └─ NO → move_vma()
└─ mmap_write_unlock()  # mmap 잠금 해제

흐름 설명

1. 진입점: SYSCALL_DEFINE5(mremap)이 사용자로부터 파라미터를 받아 vma_remap_struct를 초기화합니다.

2. 파라미터 검증: check_mremap_params()가 플래그, 주소 정렬, 크기 제한 등을 검증합니다.

3. 잠금 획득: mmap_write_lock_killable()로 mmap 쓰기 잠금을 획득합니다.

4. 경로 선택:

- vrm_move_only()가 true이면 remap_move()로 여러 VMA를 한 번에 이동합니다.

- 아니면 단일 VMA 처리 경로를 따릅니다.

5. VMA 처리:

- mremap_to(): MREMAP_FIXED 플래그로 지정된 주소로 이동

- mremap_at(): 주소 지정 없이 크기 변경

6. 페이지 테이블 이동: move_page_tables()가 PUD→PMD→PTE 순서로 페이지 테이블을 이동합니다.

7. 성능 최적화:

- try_realign_addr(): PMD 경계에 정렬하여 처리 효율 향상

- mremap_folio_pte_batch(): large folio의 경우 여러 PTE를 한 번에 처리

8. 마무리: mmap 잠금 해제, userfaultfd 알림, mlock된 영역 populate 처리

---

조건별 비교

1. MREMAP 플래그별 동작

플래그	값	동작	사용 시나리오
MREMAP_MAYMOVE	1	이동 허용	기본 mremap 사용 시
MREMAP_FIXED	2	고정 주소로 이동	특정 주소에 매핑 강제
MREMAP_DONTUNMAP	4	원본 유지	프로세스 간 공유 메모리 복사

2. 리매핑 타입별 처리

타입	조건	처리 방법	결과
MREMAP_NO_RESIZE	old_len == new_len	즉시 반환	no-op
MREMAP_SHRINK	old_len > new_len	in-place 축소	새 주소 반환
MREMAP_EXPAND	old_len < new_len	in-place 확장 또는 이동	새 주소 반환

3. 페이지 테이블 이동 우선순위

레벨	조건	이동 방법	성능
HPAGE_PUD	Huge PUD + 정렬	move_huge_pud()	가장 빠름
NORMAL_PUD	일반 PUD + 정렬	move_normal_pud()	빠름
HPAGE_PMD	Huge PMD + 정렬	move_huge_pmd()	빠름
NORMAL_PMD	일반 PMD + 정렬	move_normal_pmd()	보통
PTE	일반 페이지	move_ptes()	가장 느림

4. 특수 처리 조건

조건	처리	설명
HugeTLB 페이지	move_hugetlb_page_tables()	별도의 huge page 테이블 이동
uffd-wp 등록	pte_clear_uffd_wp()	userfaultfd-wp 마커 제거
VM_ACCOUNT	vrm_calc_charge()	메모리 계정 청구
VM_LOCKED	populate_expand	확장 영역 자동 populate
KSM 페이지	ksm_madvise(MADV_UNMERGEABLE)	KSM 병합 해제
mseal()된 VMA	check_prep_vma()에서 거부	봉인된 VMA 리매핑 불가
large folio	mremap_folio_pte_batch()	여러 PTE 배치 처리

5. 확장/축소 동작 비교

연산	조건	in-place 가능	이동 필요
확장 (EXPAND)	VMA 끝부분 + 빈 공간	가능	불가능 시 이동
축소 (SHRINK)	VMA 끝부분 제거	항상 가능	불필요
이동 (MOVE)	새 주소 지정	불가능	항상 이동

6. rmap 잠금 처리 비교

레벨	rmap 잠금	설명
NORMAL_PMD	항상 필요	일반 PMD 레벨 이동
NORMAL_PUD	항상 필요	일반 PUD 레벨 이동
HPAGE_PMD	선택적	Huge PMD 이동 시
HPAGE_PUD	선택적	Huge PUD 이동 시
PTE	선택적	PTE 레벨 이동 시

---

관련 문서

메모리 관리 개요

Buddy Allocator

VMA / mmap

Compaction

Migration

mprotect

Page Table Walk