Page MenuHomeFreeBSD

D61648.1795452352.diff
No OneTemporary

Authored By
Unknown
Size
8 KB
Referenced Files
None
Subscribers
None

D61648.1795452352.diff

diff --git a/sys/kern/kern_kexec.c b/sys/kern/kern_kexec.c
--- a/sys/kern/kern_kexec.c
+++ b/sys/kern/kern_kexec.c
@@ -126,7 +126,9 @@
s1 = seg1;
s2 = seg2;
- return ((uintptr_t)s1->mem - (uintptr_t)s2->mem);
+ if (s1->mem < s2->mem)
+ return (-1);
+ return (s1->mem > s2->mem);
}
static bool
@@ -201,12 +203,17 @@
* - All segments must not overlap the kernel, so must be fully enclosed
* in a vm_phys_seg (each kexec segment must be in a single
* vm_phys_seg segment, cannot cross even adjacent segments).
+ * - Segments must not be empty, as the MD code stops at the
+ * first empty one, and must not overlap each other.
*/
image_count = 0;
for (i = 0; i < nseg; i++) {
if ((segtmp[i].mem & PAGE_MASK) != 0 ||
(segtmp[i].memsz & PAGE_MASK) != 0 ||
+ segtmp[i].memsz == 0 ||
!segment_fits(&segtmp[i]) ||
+ (i > 0 && segtmp[i].mem <
+ segtmp[i - 1].mem + segtmp[i - 1].memsz) ||
segtmp[i].bufsz > segtmp[i].memsz) {
err = EINVAL;
goto out;
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
@@ -18,18 +18,25 @@
#include <atf-c.h>
+#define NPHYSSEG 64
+
+struct physseg {
+ vm_paddr_t start;
+ vm_paddr_t end;
+};
+
/*
- * Return a page-aligned physical address with at least two pages left in
- * its vm_phys segment, parsed from vm.phys_segs.
+ * Fill segs with the vm_phys segments, parsed from vm.phys_segs, and return
+ * how many there are.
*/
-static vm_paddr_t
-find_target(void)
+static int
+get_phys_segs(struct physseg *segs, int max)
{
char *buf, *line, *p;
uintmax_t start, end;
- vm_paddr_t target;
size_t len;
bool have_start;
+ int n;
len = 0;
ATF_REQUIRE(sysctlbyname("vm.phys_segs", NULL, &len, NULL, 0) == 0);
@@ -37,28 +44,82 @@
ATF_REQUIRE(buf != NULL);
ATF_REQUIRE(sysctlbyname("vm.phys_segs", buf, &len, NULL, 0) == 0);
- target = 0;
+ n = 0;
have_start = false;
start = 0;
p = buf;
- while ((line = strsep(&p, "\n")) != NULL) {
+ while (n < max && (line = strsep(&p, "\n")) != NULL) {
if (sscanf(line, "start: %jx", &start) == 1) {
have_start = true;
} else if (have_start && sscanf(line, "end: %jx", &end) == 1) {
have_start = false;
- start = roundup2(start, PAGE_SIZE);
- if (end > start && end - start >= 2 * PAGE_SIZE) {
- target = start;
- break;
- }
+ segs[n].start = start;
+ segs[n].end = end;
+ n++;
}
}
free(buf);
+ return (n);
+}
+
+/*
+ * Return a page-aligned physical address at or above min with at least size
+ * bytes left in its vm_phys segment, or 0 if there is none.
+ */
+static vm_paddr_t
+find_range(vm_paddr_t min, vm_size_t size)
+{
+ struct physseg segs[NPHYSSEG];
+ vm_paddr_t start;
+ int i, n;
+
+ n = get_phys_segs(segs, nitems(segs));
+ for (i = 0; i < n; i++) {
+ start = roundup2(MAX(segs[i].start, min), PAGE_SIZE);
+ if (segs[i].end > start && segs[i].end - start >= size)
+ return (start);
+ }
+ return (0);
+}
+
+/*
+ * Return a page-aligned physical address with at least two pages left in
+ * its vm_phys segment.
+ */
+static vm_paddr_t
+find_target(void)
+{
+ vm_paddr_t target;
+
+ target = find_range(0, 2 * PAGE_SIZE);
if (target == 0)
atf_tc_skip("no usable vm_phys segment");
return (target);
}
+/*
+ * Return a usable page above low whose distance from low has bit 31 set, or 0
+ * if there is none. Truncating that distance to an int makes it negative.
+ */
+static vm_paddr_t
+find_far_target(vm_paddr_t low)
+{
+ struct physseg segs[NPHYSSEG];
+ vm_paddr_t d, high;
+ int i, n;
+
+ n = get_phys_segs(segs, nitems(segs));
+ for (i = 0; i < n; i++) {
+ high = roundup2(MAX(segs[i].start, low + PAGE_SIZE), PAGE_SIZE);
+ d = high - low;
+ if ((d & 0x80000000) == 0)
+ high = low + (d | 0x7fffffff) + 1;
+ if (segs[i].end > high && segs[i].end - high >= PAGE_SIZE)
+ return (high);
+ }
+ return (0);
+}
+
static void
require_kexec(void)
{
@@ -91,6 +152,20 @@
}
}
+/*
+ * Skip unless a one page image can be staged at target. Some configurations
+ * reject every image (amd64 with LA57), and a test expecting EINVAL would then
+ * pass without checking anything.
+ */
+static void
+require_loadable(vm_paddr_t target, void *src)
+{
+ if (!load_one(target, src))
+ atf_tc_skip("kexec_load_md rejected the image: %s",
+ strerror(errno));
+ ATF_REQUIRE(kexec_load(0, 0, NULL, 0) == 0);
+}
+
ATF_TC(kexec_copyin_fault);
ATF_TC_HEAD(kexec_copyin_fault, tc)
{
@@ -191,10 +266,134 @@
ATF_REQUIRE(munmap(src, 2 * PAGE_SIZE) == 0);
}
+/* Large enough that the staging area needs more than a few page tables. */
+#define BIG_SEGMENT (32 * 1024 * 1024)
+
+ATF_TC(kexec_empty_segment);
+ATF_TC_HEAD(kexec_empty_segment, tc)
+{
+ atf_tc_set_md_var(tc, "descr",
+ "a segment with memsz 0 is rejected");
+ atf_tc_set_md_var(tc, "require.user", "root");
+}
+ATF_TC_BODY(kexec_empty_segment, tc)
+{
+ struct kexec_segment seg[2];
+ vm_paddr_t target;
+ void *src;
+
+ require_kexec();
+ target = find_range(0, PAGE_SIZE + BIG_SEGMENT);
+ if (target == 0)
+ atf_tc_skip("no vm_phys segment with 32MB free");
+
+ src = mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE,
+ MAP_ANON | MAP_PRIVATE, -1, 0);
+ ATF_REQUIRE(src != MAP_FAILED);
+ require_loadable(target, src);
+
+ /* The empty segment sorts first, ahead of a large one. */
+ memset(seg, 0, sizeof(seg));
+ seg[0].mem = target;
+ seg[1].buf = src;
+ seg[1].bufsz = PAGE_SIZE;
+ seg[1].mem = target + PAGE_SIZE;
+ seg[1].memsz = BIG_SEGMENT;
+ ATF_REQUIRE_ERRNO(EINVAL,
+ kexec_load(target + PAGE_SIZE, 2, seg, 0) == -1);
+
+ ATF_REQUIRE(kexec_load(0, 0, NULL, 0) == 0);
+ ATF_REQUIRE(munmap(src, PAGE_SIZE) == 0);
+}
+
+ATF_TC(kexec_overlapping_segments);
+ATF_TC_HEAD(kexec_overlapping_segments, tc)
+{
+ atf_tc_set_md_var(tc, "descr",
+ "segments whose targets overlap are rejected");
+ atf_tc_set_md_var(tc, "require.user", "root");
+}
+ATF_TC_BODY(kexec_overlapping_segments, tc)
+{
+ struct kexec_segment seg[2];
+ vm_paddr_t target;
+ void *src;
+
+ require_kexec();
+ target = find_range(0, 3 * PAGE_SIZE);
+ if (target == 0)
+ atf_tc_skip("no vm_phys segment with 3 pages free");
+
+ src = mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE,
+ MAP_ANON | MAP_PRIVATE, -1, 0);
+ ATF_REQUIRE(src != MAP_FAILED);
+ require_loadable(target, src);
+
+ memset(seg, 0, sizeof(seg));
+ seg[0].buf = src;
+ seg[0].bufsz = PAGE_SIZE;
+ seg[0].mem = target;
+ seg[0].memsz = 2 * PAGE_SIZE;
+ seg[1].buf = src;
+ seg[1].bufsz = PAGE_SIZE;
+ seg[1].mem = target + PAGE_SIZE;
+ seg[1].memsz = 2 * PAGE_SIZE;
+ ATF_REQUIRE_ERRNO(EINVAL, kexec_load(target, 2, seg, 0) == -1);
+
+ ATF_REQUIRE(kexec_load(0, 0, NULL, 0) == 0);
+ ATF_REQUIRE(munmap(src, PAGE_SIZE) == 0);
+}
+
+ATF_TC(kexec_distant_segments);
+ATF_TC_HEAD(kexec_distant_segments, tc)
+{
+ atf_tc_set_md_var(tc, "descr",
+ "segments more than 2GB apart are sorted correctly");
+ atf_tc_set_md_var(tc, "require.user", "root");
+}
+ATF_TC_BODY(kexec_distant_segments, tc)
+{
+ struct kexec_segment seg[2];
+ vm_paddr_t high, low;
+ void *src;
+
+ require_kexec();
+ low = find_target();
+ high = find_far_target(low);
+ if (high == 0)
+ atf_tc_skip("no usable page 2GB away from %#jx",
+ (uintmax_t)low);
+
+ src = mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE,
+ MAP_ANON | MAP_PRIVATE, -1, 0);
+ ATF_REQUIRE(src != MAP_FAILED);
+ require_loadable(low, src);
+
+ /* Pass them in descending order so that the kernel has to sort. */
+ memset(seg, 0, sizeof(seg));
+ seg[0].buf = src;
+ seg[0].bufsz = PAGE_SIZE;
+ seg[0].mem = high;
+ seg[0].memsz = PAGE_SIZE;
+ seg[1].buf = src;
+ seg[1].bufsz = PAGE_SIZE;
+ seg[1].mem = low;
+ seg[1].memsz = PAGE_SIZE;
+ ATF_REQUIRE_MSG(kexec_load(low, 2, seg, 0) == 0,
+ "segments at %#jx and %#jx: %s", (uintmax_t)low, (uintmax_t)high,
+ strerror(errno));
+
+ ATF_REQUIRE(kexec_load(0, 0, NULL, 0) == 0);
+ 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_load_unload);
+ ATF_TP_ADD_TC(tp, kexec_overlapping_segments);
return (atf_no_error());
}

File Metadata

Mime Type
text/plain
Expires
Mon, Nov 23, 4:45 PM (21 h, 14 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
41935155
Default Alt Text
D61648.1795452352.diff (8 KB)

Event Timeline