Page MenuHomeFreeBSD

D61649.1795458453.diff
No OneTemporary

Authored By
Unknown
Size
8 KB
Referenced Files
None
Subscribers
None

D61649.1795458453.diff

diff --git a/sys/amd64/amd64/kexec_support.c b/sys/amd64/amd64/kexec_support.c
--- a/sys/amd64/amd64/kexec_support.c
+++ b/sys/amd64/amd64/kexec_support.c
@@ -63,7 +63,7 @@
* identity: This is for an identity map, treat `start` as a physical address.
* Only valid here if do_pte is false.
*/
-static void
+static int
kexec_generate_page_tables(pml4_entry_t *root, vm_offset_t start,
vm_size_t size, bool do_pte, bool identity, struct pctrie_iter *pages)
{
@@ -85,6 +85,8 @@
*/
if (root[i] == 0) {
m = vm_radix_iter_next(pages);
+ if (m == NULL)
+ return (ENOMEM);
mpa = VM_PAGE_TO_PHYS(m);
root[i] = mpa | PG_RW | PG_V;
}
@@ -92,6 +94,8 @@
for (; j < NPDPEPG && pg < start + size; j++, k = 0, l = 0) {
if (pdp[j] == 0) {
m = vm_radix_iter_next(pages);
+ if (m == NULL)
+ return (ENOMEM);
mpa = VM_PAGE_TO_PHYS(m);
pdp[j] = mpa | PG_RW | PG_V;
}
@@ -106,6 +110,8 @@
continue;
}
m = vm_radix_iter_next(pages);
+ if (m == NULL)
+ return (ENOMEM);
mpa = VM_PAGE_TO_PHYS(m);
pde[k] = mpa | PG_V | PG_RW;
} else if ((pde[k] & PG_PS) != 0) {
@@ -123,6 +129,7 @@
}
}
}
+ return (0);
}
void
@@ -147,7 +154,7 @@
pdp_entry_t *PDP_l;
pd_entry_t *PD_l0;
vm_offset_t va;
- int i;
+ int error, i;
/*
* Start building the page table.
@@ -193,21 +200,30 @@
PG_RW | PG_PS;
}
- /* Map the target(s) in 2MB chunks. */
+ /*
+ * Map the target(s) in 2MB chunks. The pages come from the count in
+ * kexec_md_pages(), so running out means that count is wrong.
+ */
for (i = 0; i < KEXEC_SEGMENT_MAX; i++) {
struct kexec_segment_stage *s = &image->segments[i];
if (s->size == 0)
break;
- kexec_generate_page_tables(PT4, s->target, s->size, false,
- true, &pct_iter);
+ error = kexec_generate_page_tables(PT4, s->target, s->size,
+ false, true, &pct_iter);
+ if (error != 0)
+ return (error);
}
/* Now create the source page tables */
- kexec_generate_page_tables(PT4, image->map_addr, image->map_size, true,
- false, &pct_iter);
- kexec_generate_page_tables(PT4,
+ error = kexec_generate_page_tables(PT4, image->map_addr,
+ image->map_size, true, false, &pct_iter);
+ if (error != 0)
+ return (error);
+ error = kexec_generate_page_tables(PT4,
trunc_page((vm_offset_t)kexec_do_reboot_trampoline),
PAGE_SIZE, true, false, &pct_iter);
+ if (error != 0)
+ return (error);
KASSERT(m != NULL, ("kexec_load_md: Missing trampoline page!\n"));
/* MD control pages start at this next page. */
@@ -223,76 +239,58 @@
}
/*
- * Required pages:
- * - L4 (1) (root)
- * - L3 (PDPE) - 2 (bottom 512GB, bottom 4 used, top range for kernel map)
- * - L2 (PDP) - 5 (2MB superpage mappings, 1GB each, for bottom 4GB, top 1)
- * - L1 (PDR) - 1 (kexec trampoline page, first MD page)
- * - kexec_do_reboot trampoline - 1
- * - Slop pages for staging (in case it's not aligned nicely) - 3 (worst case)
- *
- * Minimum 9 pages for the direct map.
+ * Upper bound on the page table pages below the L4 needed to map [start, end):
+ * one L3 page per 512GB region, one L2 page per 1GB region and, if do_pte is
+ * set, one L1 page per 2MB region.
+ */
+static vm_size_t
+kexec_pt_pages(vm_offset_t start, vm_offset_t end, bool do_pte)
+{
+ vm_size_t n;
+
+ n = (end - 1) / NBPML4 - start / NBPML4 + 1;
+ n += (end - 1) / NBPDP - start / NBPDP + 1;
+ if (do_pte)
+ n += (end - 1) / NBPDR - start / NBPDR + 1;
+ return (n);
+}
+
+/*
+ * Pages used by kexec_load_md():
+ * - The L4, one L3 and four L2 pages that identity map the bottom 4GB.
+ * - The copy of kexec_do_reboot(), with the saved image and its stack.
+ * - L3 and L2 pages to identity map the targets above 4GB with 2MB pages.
+ * - L3, L2 and L1 pages to map the staging area with 4KB pages. The area
+ * holds the image and these pages, and it can start anywhere in the kernel
+ * map, so allow one more page per level.
+ * - L3, L2 and L1 pages for the page holding kexec_do_reboot_trampoline().
*/
int
-kexec_md_pages(struct kexec_segment *seg_in)
+kexec_md_pages(struct kexec_segment *segs)
{
- struct kexec_segment *segs = seg_in;
- vm_size_t pages = 13; /* Minimum number of starting pages */
- vm_paddr_t cur_addr = (1UL << 32) - 1; /* Bottom 4G will be identity mapped in full */
- vm_size_t source_total = 0;
+ vm_paddr_t end, start;
+ vm_size_t image, pages, prev, src;
+ pages = 6 + howmany(kexec_do_reboot_size, PAGE_SIZE) + 3;
+ image = 0;
for (int i = 0; i < KEXEC_SEGMENT_MAX; i++) {
- vm_offset_t start, end;
if (segs[i].memsz == 0)
break;
+ image += atop(segs[i].memsz);
- end = round_2mpage((vm_offset_t)segs[i].mem + segs[i].memsz);
- start = trunc_2mpage((vm_offset_t)segs[i].mem);
- start = max(start, cur_addr + 1);
- /*
- * Round to cover the full range of page table pages for each
- * segment.
- */
- source_total += round_2mpage(end - start);
-
- /*
- * Bottom 4GB are identity mapped already in the count, so skip
- * any segments that end up there, this will short-circuit that.
- */
- if (end <= cur_addr + 1)
+ end = round_2mpage(segs[i].mem + segs[i].memsz);
+ if (end <= (1UL << 32))
continue;
-
- if (pmap_pml4e_index(end) != pmap_pml4e_index(cur_addr)) {
- /* Need a new 512GB mapping page */
- pages++;
- pages += howmany(end - (start & ~PML4MASK), NBPML4);
- pages += howmany(end - (start & ~PDPMASK), NBPDP);
- pages += howmany(end - (start & ~PDRMASK), NBPDR);
-
- } else if (pmap_pdpe_index(end) != pmap_pdpe_index(cur_addr)) {
- pages++;
- pages += howmany(end - (start & ~PDPMASK), NBPDP) - 1;
- pages += howmany(end - (start & ~PDRMASK), NBPDR);
- }
-
+ start = MAX(trunc_2mpage(segs[i].mem), 1UL << 32);
+ pages += kexec_pt_pages(start, end, false);
}
- /* Be pessimistic when totaling up source pages. We likely
- * can't use superpages, so need to map each page individually.
- */
- pages += howmany(source_total, NBPDR);
- pages += howmany(source_total, NBPDP);
- pages += howmany(source_total, NBPML4);
-
- /*
- * Be intentionally sloppy adding in the extra page table pages. It's
- * better to go over than under.
- */
- pages += howmany(pages * PAGE_SIZE, NBPDR);
- pages += howmany(pages * PAGE_SIZE, NBPDP);
- pages += howmany(pages * PAGE_SIZE, NBPML4);
- /* Add in the trampoline pages */
- pages += howmany(kexec_do_reboot_size, PAGE_SIZE);
+ /* The staging area includes its own page tables, so iterate. */
+ src = 0;
+ do {
+ prev = src;
+ src = kexec_pt_pages(0, ptoa(image + pages + prev), true) + 3;
+ } while (src != prev);
- return (pages);
+ return (pages + src);
}
diff --git a/tests/sys/kern/kexec_test.c b/tests/sys/kern/kexec_test.c
--- a/tests/sys/kern/kexec_test.c
+++ b/tests/sys/kern/kexec_test.c
@@ -120,6 +120,18 @@
return (0);
}
+static u_int
+wired_pages(void)
+{
+ u_int v;
+ size_t len;
+
+ len = sizeof(v);
+ ATF_REQUIRE(sysctlbyname("vm.stats.vm.v_wire_count", &v, &len, NULL,
+ 0) == 0);
+ return (v);
+}
+
static void
require_kexec(void)
{
@@ -387,12 +399,50 @@
ATF_REQUIRE(munmap(src, PAGE_SIZE) == 0);
}
+/* Generous bound on the pages wired to stage a one page image. */
+#define ONE_PAGE_WIRE_MAX 512
+
+ATF_TC(kexec_high_segment);
+ATF_TC_HEAD(kexec_high_segment, tc)
+{
+ atf_tc_set_md_var(tc, "descr",
+ "staging one page above 4GB wires a bounded number of pages");
+ atf_tc_set_md_var(tc, "require.user", "root");
+}
+ATF_TC_BODY(kexec_high_segment, tc)
+{
+ vm_paddr_t target;
+ u_int after, before;
+ void *src;
+
+ require_kexec();
+ target = find_range((vm_paddr_t)1 << 32, PAGE_SIZE);
+ if (target == 0)
+ atf_tc_skip("no usable memory above 4GB");
+
+ src = mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE,
+ MAP_ANON | MAP_PRIVATE, -1, 0);
+ ATF_REQUIRE(src != MAP_FAILED);
+ require_loadable(target, src);
+
+ before = wired_pages();
+ ATF_REQUIRE(load_one(target, src));
+ after = wired_pages();
+ ATF_REQUIRE(kexec_load(0, 0, NULL, 0) == 0);
+
+ ATF_CHECK_MSG(after < before || after - before < ONE_PAGE_WIRE_MAX,
+ "staging one page at %#jx wired %u pages", (uintmax_t)target,
+ after - before);
+ ATF_REQUIRE(munmap(src, PAGE_SIZE) == 0);
+}
+
ATF_TP_ADD_TCS(tp)
{
ATF_TP_ADD_TC(tp, kexec_bad_segment);
ATF_TP_ADD_TC(tp, kexec_copyin_fault);
ATF_TP_ADD_TC(tp, kexec_distant_segments);
ATF_TP_ADD_TC(tp, kexec_empty_segment);
+ ATF_TP_ADD_TC(tp, kexec_high_segment);
ATF_TP_ADD_TC(tp, kexec_load_unload);
ATF_TP_ADD_TC(tp, kexec_overlapping_segments);
return (atf_no_error());

File Metadata

Mime Type
text/plain
Expires
Mon, Nov 23, 6:27 PM (22 h, 47 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
41928054
Default Alt Text
D61649.1795458453.diff (8 KB)

Event Timeline