Page Menu
Home
FreeBSD
Search
Configure Global Search
Log In
Files
F177860781
D61648.1795452352.diff
No One
Temporary
Actions
View File
Edit File
Delete File
View Transforms
Subscribe
Flag For Later
Award Token
Authored By
Unknown
Size
8 KB
Referenced Files
None
Subscribers
None
D61648.1795452352.diff
View Options
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
Details
Attached
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)
Attached To
Mode
D61648: kexec: fix the segment sort and reject empty and overlapping segments
Attached
Detach File
Event Timeline