git: 80626f785be0 - releng/15.2 - vm_map: Fix handling of largepage mappings
- Go to: [ bottom of page ] [ top of archives ] [ this month ]
Date: Tue, 17 Nov 2026 17:09:55 UTC
The branch releng/15.2 has been updated by markj:
URL: https://cgit.FreeBSD.org/src/commit/?id=80626f785be03fe61cd661c9f400317945b0de3d
commit 80626f785be03fe61cd661c9f400317945b0de3d
Author: Mark Johnston <markj@FreeBSD.org>
AuthorDate: 2026-11-13 15:14:28 +0000
Commit: Mark Johnston <markj@FreeBSD.org>
CommitDate: 2026-11-17 13:36:38 +0000
vm_map: Fix handling of largepage mappings
vm_map_pmap_enter() is not aware of largepage objects and enters their
constituent 4KB pages into the pmap. This permits mapping a constituent
page after the corresponding largepage object is freed, which can be
abused to escalate privileges. Simply don't pass largepage mappings to
it.
Modify vm_fault_copy_entry() to handle largepage mappings for the case
where mprotect() needs to eagerly upgrade protections on a wired
largepage mapping.
Approved by: re (cperciva)
Approved by: so
Security: FreeBSD-SA-26:90.vm
Security: CVE-2026-127744
Reviewed by: alc, kib
Reported by: OpenAI Security Research Team
Reported by: Albert at Vexera AI
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D61363
---
sys/vm/vm_fault.c | 34 +++++++++++++++-----
sys/vm/vm_map.c | 6 ++--
tests/sys/posixshm/posixshm_test.c | 63 ++++++++++++++++++++++++++++++++++++++
3 files changed, 94 insertions(+), 9 deletions(-)
diff --git a/sys/vm/vm_fault.c b/sys/vm/vm_fault.c
index 907b02f5833a..372163bca7a9 100644
--- a/sys/vm/vm_fault.c
+++ b/sys/vm/vm_fault.c
@@ -2289,9 +2289,10 @@ vm_fault_copy_entry(vm_map_t dst_map, vm_map_t src_map __unused,
vm_object_t backing_object, dst_object, object, src_object;
vm_pindex_t dst_pindex, pindex, src_pindex;
vm_prot_t access, prot;
- vm_offset_t vaddr;
- vm_page_t dst_m;
- vm_page_t src_m;
+ vm_offset_t va;
+ vm_page_t dst_m, m, src_m;
+ size_t psize;
+ int bdry_idx;
bool upgrade;
upgrade = src_entry == dst_entry;
@@ -2312,6 +2313,26 @@ vm_fault_copy_entry(vm_map_t dst_map, vm_map_t src_map __unused,
if (!upgrade)
access &= ~VM_PROT_WRITE;
+ if ((bdry_idx = MAP_ENTRY_SPLIT_BOUNDARY_INDEX(dst_entry)) != 0) {
+ KASSERT(upgrade,
+ ("%s: copying between largepage mappings", __func__));
+ KASSERT((dst_entry->eflags & MAP_ENTRY_USER_WIRED) != 0,
+ ("%s: largepage mapping isn't wired", __func__));
+
+ object = dst_entry->object.vm_object;
+ psize = pagesizes[bdry_idx];
+ for (va = dst_entry->start,
+ pindex = OFF_TO_IDX(dst_entry->offset);
+ va < dst_entry->end; va += psize, pindex += atop(psize)) {
+ m = vm_page_lookup_unlocked(object, pindex);
+
+ (void)pmap_enter(dst_map->pmap, va, m, prot,
+ access | PMAP_ENTER_WIRED | PMAP_ENTER_LARGEPAGE,
+ bdry_idx);
+ }
+ return;
+ }
+
src_object = src_entry->object.vm_object;
src_pindex = OFF_TO_IDX(src_entry->offset);
@@ -2362,9 +2383,8 @@ vm_fault_copy_entry(vm_map_t dst_map, vm_map_t src_map __unused,
* regardless of whether they can be written.
*/
vm_page_iter_init(&pages, dst_object);
- for (vaddr = dst_entry->start, dst_pindex = 0;
- vaddr < dst_entry->end;
- vaddr += PAGE_SIZE, dst_pindex++) {
+ for (va = dst_entry->start, dst_pindex = 0; va < dst_entry->end;
+ va += PAGE_SIZE, dst_pindex++) {
again:
/*
* Find the page in the source object, and copy it in.
@@ -2463,7 +2483,7 @@ again:
*/
if (vm_page_all_valid(dst_m)) {
VM_OBJECT_WUNLOCK(dst_object);
- pmap_enter(dst_map->pmap, vaddr, dst_m, prot,
+ pmap_enter(dst_map->pmap, va, dst_m, prot,
access | (upgrade ? PMAP_ENTER_WIRED : 0), 0);
VM_OBJECT_WLOCK(dst_object);
}
diff --git a/sys/vm/vm_map.c b/sys/vm/vm_map.c
index 94dd7d3a19bc..132f5eac0e23 100644
--- a/sys/vm/vm_map.c
+++ b/sys/vm/vm_map.c
@@ -1839,7 +1839,8 @@ vm_map_insert1(vm_map_t map, vm_object_t object, vm_ooffset_t offset,
vm_map_try_merge_entries(map, prev_entry, new_entry);
*res = vm_map_try_merge_entries(map, new_entry, next_entry);
- if ((cow & (MAP_PREFAULT | MAP_PREFAULT_PARTIAL)) != 0) {
+ if ((cow & (MAP_PREFAULT | MAP_PREFAULT_PARTIAL)) != 0 &&
+ (cow & MAP_SPLIT_BOUNDARY_MASK) == 0) {
vm_map_pmap_enter(map, start, prot, object, OFF_TO_IDX(offset),
end - start, cow & MAP_PREFAULT_PARTIAL);
}
@@ -3160,7 +3161,8 @@ vm_map_madvise(
vm_offset_t useEnd, useStart;
if ((entry->eflags & (MAP_ENTRY_IS_SUB_MAP |
- MAP_ENTRY_GUARD)) != 0)
+ MAP_ENTRY_GUARD | MAP_ENTRY_SPLIT_BOUNDARY_MASK)) !=
+ 0)
continue;
/*
diff --git a/tests/sys/posixshm/posixshm_test.c b/tests/sys/posixshm/posixshm_test.c
index 08af63ac4a34..24ac80969a64 100644
--- a/tests/sys/posixshm/posixshm_test.c
+++ b/tests/sys/posixshm/posixshm_test.c
@@ -1654,6 +1654,68 @@ ATF_TC_BODY(largepage_mlock, tc)
}
}
+/*
+ * Test handling of the RO->RW transition for an mlocked largepage mapping.
+ */
+ATF_TC(largepage_mprotect_wired);
+ATF_TC_HEAD(largepage_mprotect_wired, tc)
+{
+ /* Needed to set rlimit. */
+ atf_tc_set_md_var(tc, "require.user", "root");
+}
+ATF_TC_BODY(largepage_mprotect_wired, tc)
+{
+ struct rlimit rl;
+ char *addr;
+ size_t ps[MAXPAGESIZES], sz;
+ u_long max_wired, wired;
+ int fd, error, pscnt;
+
+ rl.rlim_cur = rl.rlim_max = RLIM_INFINITY;
+ ATF_REQUIRE_MSG(setrlimit(RLIMIT_MEMLOCK, &rl) == 0,
+ "setrlimit failed; error=%d", errno);
+
+ sz = sizeof(max_wired);
+ error = sysctlbyname("vm.max_user_wired", &max_wired, &sz, NULL, 0);
+ ATF_REQUIRE_MSG(error == 0,
+ "sysctlbyname(vm.max_user_wired) failed; error=%d", errno);
+
+ sz = sizeof(wired);
+ error = sysctlbyname("vm.stats.vm.v_user_wire_count", &wired, &sz, NULL,
+ 0);
+ ATF_REQUIRE_MSG(error == 0,
+ "sysctlbyname(vm.stats.vm.v_user_wire_count) failed; error=%d",
+ errno);
+
+ pscnt = pagesizes(ps, true);
+ for (int i = 1; i < pscnt; i++) {
+ if (ps[i] / ps[0] > max_wired - wired) {
+ /* Cannot wire past the limit. */
+ atf_tc_skip("test would exceed wiring limit");
+ }
+
+ fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]);
+
+ addr = mmap(NULL, ps[i], PROT_READ, MAP_SHARED, fd, 0);
+ ATF_REQUIRE_MSG(addr != MAP_FAILED,
+ "mmap(%zu bytes) failed; error=%d", ps[i], errno);
+
+ ATF_REQUIRE_MSG(mlock(addr, ps[i]) == 0,
+ "mlock failed; error=%d", errno);
+
+ ATF_REQUIRE_MSG(mprotect(addr, ps[i],
+ PROT_READ | PROT_WRITE) == 0,
+ "mprotect failed; error=%d", errno);
+
+ memset(addr, 0x41, ps[i]);
+ ATF_REQUIRE_MSG(addr[0] == 0x41 && addr[ps[i] - 1] == 0x41,
+ "largepage contents unexpected after mprotect");
+
+ ATF_REQUIRE(munmap(addr, ps[i]) == 0);
+ ATF_REQUIRE(close(fd) == 0);
+ }
+}
+
ATF_TC_WITHOUT_HEAD(largepage_msync);
ATF_TC_BODY(largepage_msync, tc)
{
@@ -2322,6 +2384,7 @@ ATF_TP_ADD_TCS(tp)
ATF_TP_ADD_TC(tp, largepage_mlock);
ATF_TP_ADD_TC(tp, largepage_msync);
ATF_TP_ADD_TC(tp, largepage_mprotect);
+ ATF_TP_ADD_TC(tp, largepage_mprotect_wired);
ATF_TP_ADD_TC(tp, largepage_minherit);
ATF_TP_ADD_TC(tp, largepage_pipe);
#ifdef __amd64__