Skip to contentSkip to conversation

refactor mseal_test

RFC PATCH In review [email protected] 2 participants 6 messages Dec 11, 2024 – Feb 11, 2025

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

cover refactor mseal_test

From: Jeff Xu <[email protected]>

This change creates the initial version of memorysealing.c.

The introduction of memorysealing.c, which replaces mseal_test.c and uses the kselftest_harness, aims to initiate a discussion on using the selftest harness for memory sealing tests. Upon approval of this approach, the migration of tests from mseal_test.c to memorysealing.c can be implemented in a step-by-step manner.

This tests addresses following feedbacks from previous reviews:

1> Use kselftest_harness instead of custom macro, such as EXPECT_XX, ASSERT_XX, etc. (Lorenzo Stoakes, Mark Brown, etc) [1]

2> Use MAP_FAILED to check the return of mmap (Lorenzo Stoakes).

3> Adding a check for vma size and prot bits. The discussion for
this can be found in [2] [3], here is a brief summary:
This is to follow up on Pedro’s in-loop change (from can_modify_mm to can_modify_vma). When mseal_test is initially created, they have a common pattern: setup memory layout, seal the memory, perform a few mm-api steps, verify return code (not zero). Because of the nature of out-of-loop, it is sufficient to just verify the error code in a few cases.

With Pedro's in-loop change, the sealing check happens later in the stack, thus there are more things and scenarios to verify. And there were feedbacks to me that mseal_test should be extensive enough to discover all regressions. Hence I'm adding check for vma size and prot bits.

In this change: we created two fixtures:

Fixture basic: This creates a single VMA, the VMA has a
PROT_NONE page at each end to prevent auto-merging.

Fixture wo_vma: Two VMAs back to end, a PROT_NONE page at each
end to prevent auto-merging.

In addition, I add one test (mprotec) in each fixture for discussion.

[1] https://lore.kernel.org/all/[email protected]/
[2] https://lore.kernel.org/all/CABi2SkUgDZtJtRJe+J9UNdtZn=EQzZcbMB685P=1rR7DUhg=6Q@mail.gmail.com/
[3] https://lore.kernel.org/all/2qywbjb5ebtgwkh354w3lj3vhaothvubjokxq5fhyri5jeeton@duqngzo3swjz/

Jeff Xu (1):
selftest/mm: refactor mseal_test

 tools/testing/selftests/mm/.gitignore      |   1 +
 tools/testing/selftests/mm/Makefile        |   1 +
 tools/testing/selftests/mm/memorysealing.c | 182 +++++++++++++++++++++
 tools/testing/selftests/mm/memorysealing.h | 116 +++++++++++++
 tools/testing/selftests/mm/mseal_test.c    |  67 +-------
 5 files changed, 301 insertions(+), 66 deletions(-)
 create mode 100644 tools/testing/selftests/mm/memorysealing.c
 create mode 100644 tools/testing/selftests/mm/memorysealing.h
Signature · 1 line
2.47.1.613.gc27f4b7a9f-goog
#1 lore raw

RFC PATCH 1/1 selftest/mm: refactor mseal_test

From: Jeff Xu <[email protected]>

This change creates the initial version of memorysealing.c.

The introduction of memorysealing.c, which replaces mseal_test.c and uses the kselftest_harness, aims to initiate a discussion on using the selftest harness for memory sealing tests. Upon approval of this approach, the migration of tests from mseal_test.c to memorysealing.c can be implemented in a step-by-step manner.

This tests addresses following feedback from previous reviews:

1> Use kselftest_harness instead of custom macro, such as EXPECT_XX, ASSERT_XX, etc. (Lorenzo Stoakes, Mark Brown) [1]

2> Use MAP_FAILED to check the return of mmap (Lorenzo Stoakes).

3> Adding a check for vma size and prot bits. The discussion for
this can be found in [2] [3], here is a brief summary:
This is to follow up on Pedro’s in-loop change (from can_modify_mm to can_modify_vma). When mseal_test is initially created, they have a common pattern: setup memory layout, seal the memory, perform a few mm-api steps, verify return code (not zero). Because of the nature of out-of-loop, it is sufficient to just verify the error code in a few cases.

With Pedro's in-loop change, the sealing check happens later in the stack, thus there are more things and scenarios to verify. And there was feedbacks to me that mseal_test should be extensive enough to discover all regressions. Hence I'm adding check for vma size and prot bits.

In this change: we created two fixtures:

Fixture basic: This creates a single VMA, the VMA has a
PROT_NONE page at each end to prevent auto-merging.

Fixture wo_vma: Two VMAs back to end, a PROT_NONE page at each end to prevent auto-merging.

In addition, I add one test (mprotec) in each fixture to demo the tests.

[1] https://lore.kernel.org/all/[email protected]/
[2] https://lore.kernel.org/all/CABi2SkUgDZtJtRJe+J9UNdtZn=EQzZcbMB685P=1rR7DUhg=6Q@mail.gmail.com/
[3] https://lore.kernel.org/all/2qywbjb5ebtgwkh354w3lj3vhaothvubjokxq5fhyri5jeeton@duqngzo3swjz/

---
 tools/testing/selftests/mm/.gitignore      |   1 +
 tools/testing/selftests/mm/Makefile        |   1 +
 tools/testing/selftests/mm/memorysealing.c | 182 +++++++++++++++++++++
 tools/testing/selftests/mm/memorysealing.h | 116 +++++++++++++
 tools/testing/selftests/mm/mseal_test.c    |  67 +-------
 5 files changed, 301 insertions(+), 66 deletions(-)
 create mode 100644 tools/testing/selftests/mm/memorysealing.c
 create mode 100644 tools/testing/selftests/mm/memorysealing.h
tools/testing/selftests/mm/.gitignore +1 -0
index a51a947b2d1d..982234a99f20 100644
@@ -57,3 +57,4 @@ hugetlb_dio
 pkey_sighandler_tests_32
 pkey_sighandler_tests_64
 guard-pages
+memorysealing
tools/testing/selftests/mm/Makefile +1 -0
index 93a46ac633df..08876624f46d 100644
@@ -67,6 +67,7 @@ TEST_GEN_FILES += map_populate
 ifneq (,$(filter $(ARCH),arm64 riscv riscv64 x86 x86_64))
 TEST_GEN_FILES += memfd_secret
 endif
+TEST_GEN_FILES += memorysealing
 TEST_GEN_FILES += migration
 TEST_GEN_FILES += mkdirty
 TEST_GEN_FILES += mlock-random-test
tools/testing/selftests/mm/memorysealing.c new file +182 -0

182 lines not on this page · raw message

tools/testing/selftests/mm/memorysealing.h new file +116 -0

116 lines not on this page · raw message

tools/testing/selftests/mm/mseal_test.c +1 -66

97 lines not on this page · raw message

Signature · 1 line
2.47.1.613.gc27f4b7a9f-goog
#2 lore raw

Re: [RFC PATCH v1 1/1] selftest/mm: refactor mseal_test

Sorry for delay, was super busy leading up to xmas break, then had ~2.5 weeks off.

And happy new year! :)

Quoted 5 lines · On Wed, Dec 11, 2024 at 05:33:11AM +0000, [email protected] wrote:

From: Jeff Xu <[email protected]>

This change creates the initial version of memorysealing.c.

The introduction of memorysealing.c, which replaces mseal_test.c and

I mean I don't want to be a pain but I would kinda prefer to have 'mseal' everywhere mseal is to avoid confusion vs. memfd seals.

Of course we in the kernel absolutely _love_ to overload the meaning of terms but some traditions are worth breaking :)

Quoted 4 lines

uses the kselftest_harness, aims to initiate a discussion on using the selftest harness for memory sealing tests. Upon approval of this approach, the migration of tests from mseal_test.c to memorysealing.c can be implemented in a step-by-step manner.

Well, I for one like this approach so (unsurprisingly) :) but perhaps sensible to do it iteratively so we can also tweak things as we go.

Quoted 7 lines

This tests addresses following feedback from previous reviews:

1> Use kselftest_harness instead of custom macro, such as EXPECT_XX, ASSERT_XX, etc. (Lorenzo Stoakes, Mark Brown) [1]

2> Use MAP_FAILED to check the return of mmap (Lorenzo Stoakes).

Thanks!

Quoted 71 lines

3> Adding a check for vma size and prot bits. The discussion for
this can be found in [2] [3], here is a brief summary:
This is to follow up on Pedro’s in-loop change (from can_modify_mm to can_modify_vma). When mseal_test is initially created, they have a common pattern: setup memory layout, seal the memory, perform a few mm-api steps, verify return code (not zero). Because of the nature of out-of-loop, it is sufficient to just verify the error code in a few cases.

With Pedro's in-loop change, the sealing check happens later in the stack, thus there are more things and scenarios to verify. And there was feedbacks to me that mseal_test should be extensive enough to discover all regressions. Hence I'm adding check for vma size and prot bits.

In this change: we created two fixtures:

Fixture basic: This creates a single VMA, the VMA has a
PROT_NONE page at each end to prevent auto-merging.

Fixture wo_vma: Two VMAs back to end, a PROT_NONE page at each end to prevent auto-merging.

In addition, I add one test (mprotec) in each fixture to demo the tests.

[1] https://lore.kernel.org/all/[email protected]/
[2] https://lore.kernel.org/all/CABi2SkUgDZtJtRJe+J9UNdtZn=EQzZcbMB685P=1rR7DUhg=6Q@mail.gmail.com/
[3] https://lore.kernel.org/all/2qywbjb5ebtgwkh354w3lj3vhaothvubjokxq5fhyri5jeeton@duqngzo3swjz/

---
 tools/testing/selftests/mm/.gitignore      |   1 +
 tools/testing/selftests/mm/Makefile        |   1 +
 tools/testing/selftests/mm/memorysealing.c | 182 +++++++++++++++++++++
 tools/testing/selftests/mm/memorysealing.h | 116 +++++++++++++
 tools/testing/selftests/mm/mseal_test.c    |  67 +-------
 5 files changed, 301 insertions(+), 66 deletions(-)
 create mode 100644 tools/testing/selftests/mm/memorysealing.c
 create mode 100644 tools/testing/selftests/mm/memorysealing.h
tools/testing/selftests/mm/.gitignore +1 -0
index a51a947b2d1d..982234a99f20 100644
@@ -57,3 +57,4 @@ hugetlb_dio
 pkey_sighandler_tests_32
 pkey_sighandler_tests_64
 guard-pages
+memorysealing
tools/testing/selftests/mm/Makefile +1 -0
index 93a46ac633df..08876624f46d 100644
@@ -67,6 +67,7 @@ TEST_GEN_FILES += map_populate
 ifneq (,$(filter $(ARCH),arm64 riscv riscv64 x86 x86_64))
 TEST_GEN_FILES += memfd_secret
 endif
+TEST_GEN_FILES += memorysealing
 TEST_GEN_FILES += migration
 TEST_GEN_FILES += mkdirty
 TEST_GEN_FILES += mlock-random-test
tools/testing/selftests/mm/memorysealing.c new file +3 -0
new file mode 100644
index 000000000000..e10032528b64
@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#define _GNU_SOURCE
+#include "../kselftest_harness.h"

tools/testing/selftests/mm/memorysealing.c line 13

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.c new file +10 -0
+#include <asm-generic/unistd.h>
+#include <errno.h>
+#include <syscall.h>
+#include "memorysealing.h"
+
+/*
+ * To avoid auto-merging, create a VMA with PROT_NONE pages at each end.
+ * If unsuccessful, return MAP_FAILED.
+ */
+static void *setup_single_address(int size, int prot)

Nitty, but size should really be an unsigned long.

tools/testing/selftests/mm/memorysealing.c line 17

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+{
+	int ret;
+	void *ptr;
+	unsigned long page_size = getpagesize();

Trivial, but we store page size in self->page_size so why not pass it as a parameter instead of looking up?

Quoted 8 lines
tools/testing/selftests/mm/memorysealing.c new file +8 -0
+
+	ptr = mmap(NULL, size + 2 * page_size, prot,
+		MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+
+	if (ptr == MAP_FAILED)
+		return MAP_FAILED;
+
+	/* To avoid auto-merging, change to PROT_NONE at each end. */

tools/testing/selftests/mm/memorysealing.c line 35

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.c new file +10 -0
+	ret = sys_mprotect(ptr, page_size, PROT_NONE);
+	if (ret != 0)
+		return MAP_FAILED;
+
+	ret = sys_mprotect(ptr + size + page_size, page_size, PROT_NONE);
+	if (ret != 0)
+		return MAP_FAILED;
+
+	return ptr + page_size;
+}

This could be done more easily with a single PROT_NONE, like:

	static void *setup_single_address(unsigned long size, int prot,
			unsigned long page_size)
	{
		void *ptr;

		/* Ensure we only merge what we intend to. */
		ptr = mmap(NULL, size + 2 * page_size, PROT_NONE,
			   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
		if (ptr == MAP_FAILED)
			return MAP_FAILED;

		return mmap(&ptr[page_size], size, prot,
			    MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
	}

It's probably worth having an equivalent freeing function to avoid leaks:

	static int free_single_address(void *ptr, unsigned long size,
			unsigned long page_size)
	{
		/* Also free the PROT_NONE sentinels. */
		return munmap(ptr - page_size, size + 2 * page_size);
	}
Quoted 17 lines
tools/testing/selftests/mm/memorysealing.c new file +17 -0
+
+FIXTURE(basic)
+{
+	unsigned long page_size;
+	unsigned long size;
+	void *ptr;
+};
+
+/*
+ * Setup for basic:
+ * Single VMA with 4 pages, prot = (PROT_READ | PROT_WRITE).
+ */
+FIXTURE_SETUP(basic)
+{
+	int prot;
+
+	self->page_size = getpagesize();

tools/testing/selftests/mm/memorysealing.c line 62

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.c new file +10 -0
+
+	if (!mseal_supported())
+		SKIP(return, "mseal is not supported");
+
+	/* Create a single VMA with 4 pages, prot as PROT_READ | PROT_WRITE. */
+	self->size = self->page_size * 4;
+	self->ptr = setup_single_address(self->size, PROT_READ | PROT_WRITE);
+	EXPECT_NE(self->ptr, MAP_FAILED);
+
+	EXPECT_EQ(self->size, get_vma_size(self->ptr, &prot));

I mean fine but this check seems a bit overkill here, we don't need to check to ensure that PROT_NONE works.

tools/testing/selftests/mm/memorysealing.c line 63

Quoted 1 line
tools/testing/selftests/mm/memorysealing.c new file +1 -0
+	EXPECT_EQ(PROT_READ | PROT_WRITE, prot);

Nitty, but this seems a bit 'Yoda style', that is placing the expectation prior to the value whose expectation we are assessing, that is perhaps it'd be clearer as:

	EXPECT_EQ(prot, PROT_READ | PROT_WRITE);

And again, I think this is really overkill here, if the kernel is unable to do an ordinary mapping correctly we have bigger problems than an mseal bug!

tools/testing/selftests/mm/memorysealing.c line 67

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+};
+
+FIXTURE_TEARDOWN(basic)
+{

Probably worth adding munmap() teardown here.

Quoted 33 lines
tools/testing/selftests/mm/memorysealing.c new file +33 -0
+}
+
+FIXTURE(two_vma)
+{
+	unsigned long page_size;
+	unsigned long size;
+	void *ptr;
+};
+
+/*
+ * Setup for two_vma:
+ * Two consecutive VMAs, each with 2 pages.
+ * The first VMA:  prot = PROT_READ.
+ * The second VMA: prot = (PROT_READ | PROT_WRITE).
+ */
+FIXTURE_SETUP(two_vma)
+{
+	int prot;
+	int ret;
+
+	self->page_size = getpagesize();
+
+	if (!mseal_supported())
+		SKIP(return, "mseal is not supported");
+
+	/* Create a single VMA with 4 pages, prot as PROT_READ | PROT_WRITE. */
+	self->size = getpagesize() * 4;
+	self->ptr = setup_single_address(self->size, PROT_READ | PROT_WRITE);
+	EXPECT_NE(self->ptr, MAP_FAILED);
+
+	/* Use mprotect to split as two VMA. */
+	ret = sys_mprotect(self->ptr, self->page_size * 2, PROT_READ);
+	ASSERT_EQ(ret, 0);

tools/testing/selftests/mm/memorysealing.c line 109

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.c new file +9 -0
+
 
+	/* Verify the first VMA is 2 pages and prot bits */
+	EXPECT_EQ(self->page_size * 2, get_vma_size(self->ptr, &prot));
+	EXPECT_EQ(PROT_READ, prot);
+
+	/* Verify the second VMA is 2 pages and prot bits */
+	EXPECT_EQ(self->page_size * 2,
+		get_vma_size(self->ptr + self->page_size * 2, &prot));
+	EXPECT_EQ(PROT_READ | PROT_WRITE, prot);

Again, as with the prior fixture, it seems a bit overkill, as this is essentially testing 'does mmap() and mprotect()' work. We should hope so :)

tools/testing/selftests/mm/memorysealing.c line 113

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+};
+
+FIXTURE_TEARDOWN(two_vma)
+{

Same comment as for the basic fixture - let's clean up after ourselves.

Quoted 8 lines
tools/testing/selftests/mm/memorysealing.c new file +8 -0
+}
+
+/*
+ * Verify mprotect is blocked.
+ */
+TEST_F(basic, mprotect_basic)
+{
+	int ret;

tools/testing/selftests/mm/memorysealing.c line 131

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.c new file +10 -0
+	unsigned long size;
+	int prot;
+
+	/* Seal the mapping. */
+	ret = sys_mseal(self->ptr, self->size, 0);
+	ASSERT_EQ(ret, 0);
+
+	/* Verify mprotect is blocked. */
+	ret = sys_mprotect(self->ptr, self->size, PROT_READ);
+	EXPECT_GT(0, ret);

Yeah this one is kinda egregious, this is genuinely hard to read. Wouldn't this be better as:

	EXPECT_NE(ret, 0);

As it explicitly says 'not equal to a success case'. Rather than 'wait 0 is _greater than_ the result which means the result is _less than_ 0 which means an error but let me check the man page can it be positive, oh ok it's -1 on error, 0 on success', which was the Lorenzo thought process... :)

tools/testing/selftests/mm/memorysealing.c

Quoted 1 line
tools/testing/selftests/mm/memorysealing.c new file +1 -0
+	EXPECT_EQ(EPERM, errno);

Let's invert these, Yoda style isn't really useful here and is a little harder to read, e.g. we should do:

	EXPECT_EQ(errno, EPERM);

tools/testing/selftests/mm/memorysealing.c line 137

Quoted 5 lines
tools/testing/selftests/mm/memorysealing.c new file +5 -0
+
+	/* Verify the VMA (sealed) isn't changed */
+	size = get_vma_size(self->ptr, &prot);
+	EXPECT_EQ(self->size, size);
+	EXPECT_EQ(PROT_READ | PROT_WRITE, prot);

Again, no to Yoda :)

I also wonder how useful this is - I guess belts + braces, and linux _can_ do partial failures, but is that something we would care about in practice?

tools/testing/selftests/mm/memorysealing.c line 144

Quoted 7 lines
tools/testing/selftests/mm/memorysealing.c new file +7 -0
+}
+
+/*
+ * Seal both VMAs in one mseal call.
+ * Verify mprotect is blocked on both VMAs in various cases.
+ */
+TEST_F(two_vma, mprotect)

I'm guessing you aren't necessarily covering _all_ mprotect cases here (though perhaps you intend to later, iteratively?)

tools/testing/selftests/mm/memorysealing.c line 73

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+{
+	int ret;
+	int prot;
+	unsigned long size;

I think 'size' is a bit confusing as it refers to the size ascertained from the get_vma_size() later on. Perhaps call it actual_size?

Maybe worth adding:

	void *ptr = self->ptr;
	unsigned long size = self->size;
	unsigned long page_size = self->page_size;

For convenience?

This is totally optional though, maybe more effort than it's worth.

tools/testing/selftests/mm/memorysealing.c line 156

Quoted 8 lines
tools/testing/selftests/mm/memorysealing.c new file +8 -0
+
+	/* Seal both VMAs in one mseal call. */
+	ret = sys_mseal(self->ptr, self->size, 0);
+	ASSERT_EQ(ret, 0);
+
+	/* Verify mprotect is rejected on the first VMA. */
+	ret = sys_mprotect(self->ptr, self->page_size * 2,
+		PROT_READ | PROT_EXEC);

Why PROT_READ | PROT_EXEC? Is this arbitrary? To be thorough shouldn't you loop through all of the prot flags that you think should fail? And perhaps check what happens if you mprotect() the VMA to set it to what it already is?

tools/testing/selftests/mm/memorysealing.c

Quoted 1 line
tools/testing/selftests/mm/memorysealing.c new file +1 -0
+	EXPECT_GT(0, ret);

Please convert to EXPECT_NE(ret, 0)

tools/testing/selftests/mm/memorysealing.c

Quoted 1 line
tools/testing/selftests/mm/memorysealing.c new file +1 -0
+	EXPECT_EQ(EPERM, errno);

Please invert to EXPECT_EQ(errno, EPERM)

tools/testing/selftests/mm/memorysealing.c line 162

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+
+	/* Verify mprotect is rejected on the second VMA. */
+	ret = sys_mprotect(self->ptr, self->page_size * 2,
+		PROT_READ | PROT_EXEC);

Hang on, isn't this just a repeat of the first test? Shouldn't this be:

	ret = sys_mprotect(&self->ptr[self->page_size * 2],
		self->page_size * 2, PROT_READ | PROT_EXEC);

tools/testing/selftests/mm/memorysealing.c

Quoted 2 lines
tools/testing/selftests/mm/memorysealing.c new file +2 -0
+	EXPECT_GT(0, ret);
+	EXPECT_EQ(EPERM, errno);

Same comment as above re: ordering.

tools/testing/selftests/mm/memorysealing.c line 168

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+
+	/* Attempt of mprotect two VMAs at the same call is blocked */
+	ret = sys_mprotect(self->ptr, self->size,
+		PROT_READ | PROT_EXEC);

Same comment about iterating through prot flags that should fail as above.

tools/testing/selftests/mm/memorysealing.c

Quoted 2 lines
tools/testing/selftests/mm/memorysealing.c new file +2 -0
+	EXPECT_GT(0, ret);
+	EXPECT_EQ(EPERM, errno);

Same comment as above re: ordering.

tools/testing/selftests/mm/memorysealing.c line 175

Quoted 5 lines
tools/testing/selftests/mm/memorysealing.c new file +5 -0
+
+	/* Verify both VMAs aren't changed. */
+	size = get_vma_size(self->ptr, &prot);
+	EXPECT_EQ(self->page_size * 2, size);
+	EXPECT_EQ(PROT_READ, prot);

Same comment as above re: ordering.

tools/testing/selftests/mm/memorysealing.c line 179

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+
+	size = get_vma_size(self->ptr + self->page_size * 2, &prot);
+	EXPECT_EQ(self->page_size * 2, size);
+	EXPECT_EQ(PROT_READ | PROT_WRITE, prot);

Same comment as above re: ordering.

Quoted 9 lines
tools/testing/selftests/mm/memorysealing.c new file +3 -0
+}
+
+TEST_HARNESS_MAIN
tools/testing/selftests/mm/memorysealing.h new file +0 -0
new file mode 100644
index 000000000000..aee6e6700028

tools/testing/selftests/mm/memorysealing.h line 7

Quoted 7 lines
tools/testing/selftests/mm/memorysealing.h new file +7 -0
@@ -0,0 +1,116 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#include <syscall.h>
+
+/*
+ * Define sys_xyx to call syscall directly.
+ * This is needed because we want to avoid calling glibc and
+ * test syscall directly.

I do wonder if this is worth it, but I mean, I guess it's not too egregious if it's wrapped like this. Same comment for other wrappers.

tools/testing/selftests/mm/memorysealing.h line 15

Quoted 8 lines
tools/testing/selftests/mm/memorysealing.h new file +8 -0
+ * The only exception is mmap, which _NR_mmap2 is not defined for
+ * some ARM architecture.
+ */
+static inline int sys_mseal(void *start, size_t len, unsigned long flags)
+{
+	int sret;
+
+	errno = 0;

Why are we setting this to 0? Same comment for all sys_XXX() wrappers.

tools/testing/selftests/mm/memorysealing.h line 17

Quoted 2 lines
tools/testing/selftests/mm/memorysealing.h new file +2 -0
+	sret = syscall(__NR_mseal, start, len, flags);
+	return sret;

Nit, but this seems a bit redundant, why not just drop the sret assignment, and simply:

	return syscall(__NR_mseal, start, len, flags);

Same comment for all sys_XXX() wrappers.

tools/testing/selftests/mm/memorysealing.h line 28

Quoted 11 lines
tools/testing/selftests/mm/memorysealing.h new file +11 -0
+}
+
+static inline int sys_mprotect(void *ptr, size_t size, unsigned long prot)
+{
+	int sret;
+
+	errno = 0;
+	sret = syscall(__NR_mprotect, ptr, size, prot);
+	return sret;
+}
+

The wrappers below don't seem to be used yet, could we delay putting them in until they are actually used?

Quoted 37 lines
tools/testing/selftests/mm/memorysealing.h new file +37 -0
+static inline int sys_mprotect_pkey(void *ptr, size_t size,
+	unsigned long orig_prot, unsigned long pkey)
+{
+	int sret;
+
+	errno = 0;
+	sret = syscall(__NR_pkey_mprotect, ptr, size, orig_prot, pkey);
+	return sret;
+}
+
+static inline int sys_munmap(void *ptr, size_t size)
+{
+	int sret;
+
+	errno = 0;
+	sret = syscall(__NR_munmap, ptr, size);
+	return sret;
+}
+
+static inline int sys_madvise(void *start, size_t len, int types)
+{
+	int sret;
+
+	errno = 0;
+	sret = syscall(__NR_madvise, start, len, types);
+	return sret;
+}
+
+static inline void *sys_mremap(void *addr, size_t old_len, size_t new_len,
+	unsigned long flags, void *new_addr)
+{
+	void *sret;
+
+	errno = 0;
+	sret = (void *) syscall(__NR_mremap, addr, old_len, new_len, flags, new_addr);
+	return sret;
+}

tools/testing/selftests/mm/memorysealing.h line 75

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.h new file +10 -0
+
+/*
+ * Parsing /proc/self/maps to get VMA's size and prot bit.
+ */
+static unsigned long get_vma_size(void *addr, int *prot)
+{
+	FILE *maps;
+	char line[256];
+	int size = 0;
+	uintptr_t  addr_start, addr_end;

Why not add a:

	uintptr_t addr_val = (uintptr_t)addr;

To avoid having to constantly cast below?

tools/testing/selftests/mm/memorysealing.h line 77

Quoted 2 lines
tools/testing/selftests/mm/memorysealing.h new file +2 -0
+	char protstr[5];
+	*prot = 0;

Nit but not sure there's much point in setting this to 0 even in failure cases?

With an error code return you can avoid having to do this.

tools/testing/selftests/mm/memorysealing.h line 81

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.h new file +4 -0
+
+	maps = fopen("/proc/self/maps", "r");
+	if (!maps)
+		return 0;

Might it be better to return an error code or something so we can identify this case? I guess any sensible call will fail on a 0 but you're sort of just implicitly hoping for this.

tools/testing/selftests/mm/memorysealing.h line 85

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.h new file +4 -0
+
+	while (fgets(line, sizeof(line), maps)) {
+		if (sscanf(line, "%lx-%lx %4s", &addr_start, &addr_end, protstr) == 3) {
+			if (addr_start == (uintptr_t) addr) {

This is a Yoda comparison again, let's put what we're comparing first, and the thing we're comparing to afterwards, e.g.

	if ((uintptr_t)addr == addr_start) ...

Also I don't think a space after the (type) cast is necesary.

tools/testing/selftests/mm/memorysealing.h line 96

Quoted 11 lines
tools/testing/selftests/mm/memorysealing.h new file +11 -0
+				size = addr_end - addr_start;
+				if (protstr[0] == 'r')
+					*prot |= PROT_READ;
+				if (protstr[1] == 'w')
+					*prot |= PROT_WRITE;
+				if (protstr[2] == 'x')
+					*prot |= PROT_EXEC;
+				break;
+			}
+		}
+	}

On the impl: This would be neater if you used guard clauses:

	while (fgets(line, sizeof(line), maps)) {
		if (sscanf(line, "%lx-%lx %4s", &addr_start, &addr_end, protstr) != 3)
			continue;

		if (addr_val != addr_start)
			continue;

		size = addr_end - addr_start;
		if (protstr[0] == 'r')
			*prot |= PROT_READ;
		if (protstr[1] == 'w')
			*prot |= PROT_WRITE;
		if (protstr[2] == 'x')
			*prot |= PROT_EXEC;
		break;
	}

This is a lot more readable?

On doing this at all - it feels a bit crazy to check this, but I guess it might be the only way to assert things about merge/split.

I'm not sure it's _really useful_ to do that though - merges/splits are internal implementation details in effect (modulo mremap single VMA requirements), and mseal is an external interface, really the check should be around 'can forbidden operations be performed on sealed mappings'.

However, if you do really want to do this, I think it would be much better to use the new ioctl interface for this [0] which should avoid having to do unpleasant text wrangling :)

[0]:https://lore.kernel.org/all/[email protected]/

tools/testing/selftests/mm/memorysealing.h line 98

Quoted 2 lines
tools/testing/selftests/mm/memorysealing.h new file +2 -0
+	fclose(maps);
+	return size;

If we don't find the line we don't seem to be indicating this, again worth being able to pass back an error?

Quoted 5 lines
tools/testing/selftests/mm/memorysealing.h new file +5 -0
+}
+
+static inline bool mseal_supported(void)
+{
+	int ret;

tools/testing/selftests/mm/memorysealing.h line 113

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.h new file +10 -0
+	void *ptr;
+	unsigned long page_size = getpagesize();
+
+	ptr = mmap(NULL, page_size, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+	if (ptr == MAP_FAILED)
+		return false;
+
+	ret = sys_mseal(ptr, page_size, 0);
+	if (ret < 0)
+		return false;

This is kind of cute, I mean it speaks to the need I think for us to be able to expose 'is X available?' programmatically. But I digress.

I guess this is ok, as this is something that should never fail.

But we should definitely clean up after ourselves here whether this succeeds or fails.

Quoted 112 lines
tools/testing/selftests/mm/memorysealing.h new file +3 -0
+
+	return true;
+}
tools/testing/selftests/mm/mseal_test.c +1 -67
index ad17005521a8..8dd20341de3d 100644
@@ -517,30 +517,6 @@ static void test_seal_twice(void)
 	REPORT_TEST_PASS();
 }
 
-static void test_seal_mprotect(bool seal)
-{
-	void *ptr;
-	unsigned long page_size = getpagesize();
-	unsigned long size = 4 * page_size;
-	int ret;
-
-	setup_single_address(size, &ptr);
-	FAIL_TEST_IF_FALSE(ptr != (void *)-1);
-
-	if (seal) {
-		ret = seal_single_address(ptr, size);
-		FAIL_TEST_IF_FALSE(!ret);
-	}
-
-	ret = sys_mprotect(ptr, size, PROT_READ | PROT_WRITE);
-	if (seal)
-		FAIL_TEST_IF_FALSE(ret < 0);
-	else
-		FAIL_TEST_IF_FALSE(!ret);
-
-	REPORT_TEST_PASS();
-}
-
 static void test_seal_start_mprotect(bool seal)
 {
 	void *ptr;
@@ -658,41 +634,6 @@ static void test_seal_mprotect_unalign_len_variant_2(bool seal)
 	REPORT_TEST_PASS();
 }
 
-static void test_seal_mprotect_two_vma(bool seal)
-{
-	void *ptr;
-	unsigned long page_size = getpagesize();
-	unsigned long size = 4 * page_size;
-	int ret;
-
-	setup_single_address(size, &ptr);
-	FAIL_TEST_IF_FALSE(ptr != (void *)-1);
-
-	/* use mprotect to split */
-	ret = sys_mprotect(ptr, page_size * 2, PROT_READ | PROT_WRITE);
-	FAIL_TEST_IF_FALSE(!ret);
-
-	if (seal) {
-		ret = seal_single_address(ptr, page_size * 4);
-		FAIL_TEST_IF_FALSE(!ret);
-	}
-
-	ret = sys_mprotect(ptr, page_size * 2, PROT_READ | PROT_WRITE);
-	if (seal)
-		FAIL_TEST_IF_FALSE(ret < 0);
-	else
-		FAIL_TEST_IF_FALSE(!ret);
-
-	ret = sys_mprotect(ptr + page_size * 2, page_size * 2,
-			PROT_READ | PROT_WRITE);
-	if (seal)
-		FAIL_TEST_IF_FALSE(ret < 0);
-	else
-		FAIL_TEST_IF_FALSE(!ret);
-
-	REPORT_TEST_PASS();
-}
-
 static void test_seal_mprotect_two_vma_with_split(bool seal)
 {
 	void *ptr;
@@ -1876,7 +1817,7 @@ int main(void)
 	if (!pkey_supported())
 		ksft_print_msg("PKEY not supported\n");
 
-	ksft_set_plan(88);
+	ksft_set_plan(84);
 
 	test_seal_addseal();
 	test_seal_unmapped_start();
@@ -1889,9 +1830,6 @@ int main(void)
 	test_seal_zero_length();
 	test_seal_twice();
 
-	test_seal_mprotect(false);
-	test_seal_mprotect(true);
-
 	test_seal_start_mprotect(false);
 	test_seal_start_mprotect(true);
 
@@ -1904,9 +1842,6 @@ int main(void)
 	test_seal_mprotect_unalign_len_variant_2(false);
 	test_seal_mprotect_unalign_len_variant_2(true);
 
-	test_seal_mprotect_two_vma(false);
-	test_seal_mprotect_two_vma(true);
-
 	test_seal_mprotect_two_vma_with_split(false);
 	test_seal_mprotect_two_vma_with_split(true);
 
--

2.47.1.613.gc27f4b7a9f-goog

author
#3 lore raw

Re: [RFC PATCH v1 1/1] selftest/mm: refactor mseal_test

Hi Lorenzo,

Quoted 4 lines · Lorenzo Stoakes

Sorry for delay, was super busy leading up to xmas break, then had ~2.5 weeks off.

Thanks for reviewing. There are lots of comments, so it takes some time to go through comments and experiment with some of the suggested changes. Please see below.

Quoted 2 lines

And happy new year! :)

Happy new year !

Quoted 10 lines · On Wed, Dec 11, 2024 at 05:33:11AM +0000, [email protected] wrote:
Quoted 5 lines

From: Jeff Xu <[email protected]>

This change creates the initial version of memorysealing.c.

The introduction of memorysealing.c, which replaces mseal_test.c and

I mean I don't want to be a pain but I would kinda prefer to have 'mseal' everywhere mseal is to avoid confusion vs. memfd seals.

As I tried to explain, the memorysealing.c will eventually replace mseal_test.c, after all the tests are moved to use kselftest_karness. How about mseal_test_new.c ? I'm open to new names if you have one.

Quoted 11 lines

Of course we in the kernel absolutely _love_ to overload the meaning of terms but some traditions are worth breaking :)

Quoted 4 lines

uses the kselftest_harness, aims to initiate a discussion on using the selftest harness for memory sealing tests. Upon approval of this approach, the migration of tests from mseal_test.c to memorysealing.c can be implemented in a step-by-step manner.

Well, I for one like this approach so (unsurprisingly) :) but perhaps sensible to do it iteratively so we can also tweak things as we go.

Yes, that is the idea.

Quoted 85 lines
Quoted 7 lines

This tests addresses following feedback from previous reviews:

1> Use kselftest_harness instead of custom macro, such as EXPECT_XX, ASSERT_XX, etc. (Lorenzo Stoakes, Mark Brown) [1]

2> Use MAP_FAILED to check the return of mmap (Lorenzo Stoakes).

Thanks!

Quoted 75 lines

3> Adding a check for vma size and prot bits. The discussion for
this can be found in [2] [3], here is a brief summary:
This is to follow up on Pedro’s in-loop change (from can_modify_mm to can_modify_vma). When mseal_test is initially created, they have a common pattern: setup memory layout, seal the memory, perform a few mm-api steps, verify return code (not zero). Because of the nature of out-of-loop, it is sufficient to just verify the error code in a few cases.

With Pedro's in-loop change, the sealing check happens later in the stack, thus there are more things and scenarios to verify. And there was feedbacks to me that mseal_test should be extensive enough to discover all regressions. Hence I'm adding check for vma size and prot bits.

In this change: we created two fixtures:

Fixture basic: This creates a single VMA, the VMA has a
PROT_NONE page at each end to prevent auto-merging.

Fixture wo_vma: Two VMAs back to end, a PROT_NONE page at each end to prevent auto-merging.

In addition, I add one test (mprotec) in each fixture to demo the tests.

[1] https://lore.kernel.org/all/[email protected]/
[2] https://lore.kernel.org/all/CABi2SkUgDZtJtRJe+J9UNdtZn=EQzZcbMB685P=1rR7DUhg=6Q@mail.gmail.com/
[3] https://lore.kernel.org/all/2qywbjb5ebtgwkh354w3lj3vhaothvubjokxq5fhyri5jeeton@duqngzo3swjz/

---
 tools/testing/selftests/mm/.gitignore      |   1 +
 tools/testing/selftests/mm/Makefile        |   1 +
 tools/testing/selftests/mm/memorysealing.c | 182 +++++++++++++++++++++
 tools/testing/selftests/mm/memorysealing.h | 116 +++++++++++++
 tools/testing/selftests/mm/mseal_test.c    |  67 +-------
 5 files changed, 301 insertions(+), 66 deletions(-)
 create mode 100644 tools/testing/selftests/mm/memorysealing.c
 create mode 100644 tools/testing/selftests/mm/memorysealing.h
tools/testing/selftests/mm/.gitignore +1 -0
index a51a947b2d1d..982234a99f20 100644
@@ -57,3 +57,4 @@ hugetlb_dio
 pkey_sighandler_tests_32
 pkey_sighandler_tests_64
 guard-pages
+memorysealing
tools/testing/selftests/mm/Makefile +1 -0
index 93a46ac633df..08876624f46d 100644
@@ -67,6 +67,7 @@ TEST_GEN_FILES += map_populate
 ifneq (,$(filter $(ARCH),arm64 riscv riscv64 x86 x86_64))
 TEST_GEN_FILES += memfd_secret
 endif
+TEST_GEN_FILES += memorysealing
 TEST_GEN_FILES += migration
 TEST_GEN_FILES += mkdirty
 TEST_GEN_FILES += mlock-random-test
tools/testing/selftests/mm/memorysealing.c new file +7 -0
new file mode 100644
index 000000000000..e10032528b64
@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#define _GNU_SOURCE
+#include "../kselftest_harness.h"
+#include <asm-generic/unistd.h>
+#include <errno.h>
+#include <syscall.h>
+#include "memorysealing.h"
Quoted 9 lines

tools/testing/selftests/mm/memorysealing.c line 13

Quoted 6 lines
tools/testing/selftests/mm/memorysealing.c new file +6 -0
+
+/*
+ * To avoid auto-merging, create a VMA with PROT_NONE pages at each end.
+ * If unsuccessful, return MAP_FAILED.
+ */
+static void *setup_single_address(int size, int prot)

Nitty, but size should really be an unsigned long.

sure, thanks

Quoted 8 lines

tools/testing/selftests/mm/memorysealing.c line 17

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+{
+     int ret;
+     void *ptr;
+     unsigned long page_size = getpagesize();

Trivial, but we store page size in self->page_size so why not pass it as a parameter instead of looking up?

sure.

Quoted 21 lines
Quoted 8 lines
tools/testing/selftests/mm/memorysealing.c new file +8 -0
+
+     ptr = mmap(NULL, size + 2 * page_size, prot,
+             MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+
+     if (ptr == MAP_FAILED)
+             return MAP_FAILED;
+
+     /* To avoid auto-merging, change to PROT_NONE at each end. */

tools/testing/selftests/mm/memorysealing.c line 35

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.c new file +10 -0
+     ret = sys_mprotect(ptr, page_size, PROT_NONE);
+     if (ret != 0)
+             return MAP_FAILED;
+
+     ret = sys_mprotect(ptr + size + page_size, page_size, PROT_NONE);
+     if (ret != 0)
+             return MAP_FAILED;
+
+     return ptr + page_size;
+}

This could be done more easily with a single PROT_NONE, like:

Quoted 15 lines
        static void *setup_single_address(unsigned long size, int prot,
                        unsigned long page_size)
        {
                void *ptr;

                /* Ensure we only merge what we intend to. */
                ptr = mmap(NULL, size + 2 * page_size, PROT_NONE,
                           MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
                if (ptr == MAP_FAILED)
                        return MAP_FAILED;

                return mmap(&ptr[page_size], size, prot,
                            MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
        }

sure, create PROT_NONE mapping first, then use mprotect to change the middle part.

Quoted 7 lines

It's probably worth having an equivalent freeing function to avoid leaks:

        static int free_single_address(void *ptr, unsigned long size,
                        unsigned long page_size)
        {
                /* Also free the PROT_NONE sentinels. */
                return munmap(ptr - page_size, size + 2 * page_size);

[resp 1] could you clarify? I think we won't need freeing because mapping will be sealed. You might recall, mseal() blocks munmap(), and munmap() is atomic, so the above line that you suggested will result in no-action during FIXTURE_TEARDOWN. There will be separate test cases to test munmap under sealing. In addition, the virtual address space is big enough for this test complete without worry about the out-of-memory situation. Do I miss anything ?

Quoted 24 lines
        }
Quoted 22 lines
tools/testing/selftests/mm/memorysealing.c new file +22 -0
+
+FIXTURE(basic)
+{
+     unsigned long page_size;
+     unsigned long size;
+     void *ptr;
+};
+
+/*
+ * Setup for basic:
+ * Single VMA with 4 pages, prot = (PROT_READ | PROT_WRITE).
+ */
+FIXTURE_SETUP(basic)
+{
+     int prot;
+
+     self->page_size = getpagesize();
+
+     if (!mseal_supported())
+             SKIP(return, "mseal is not supported");
+
+     /* Create a single VMA with 4 pages, prot as PROT_READ | PROT_WRITE. */
Quoted 9 lines

tools/testing/selftests/mm/memorysealing.c line 62

Quoted 5 lines
tools/testing/selftests/mm/memorysealing.c new file +5 -0
+     self->size = self->page_size * 4;
+     self->ptr = setup_single_address(self->size, PROT_READ | PROT_WRITE);
+     EXPECT_NE(self->ptr, MAP_FAILED);
+
+     EXPECT_EQ(self->size, get_vma_size(self->ptr, &prot));

I mean fine but this check seems a bit overkill here, we don't need to check to ensure that PROT_NONE works.

[resp 2] Those checks are there, for the same reason that test cases usually check the return value of mmap(), mprotect() in the FIXTURE_SETUP. You are right that those calls are unlikely to fail, however, test cases generally do those "housekeeping tasks" to make sure everything is OK before the actual test. If you don't want to keep those, what is the downside of keeping them ?

Quoted 8 lines

tools/testing/selftests/mm/memorysealing.c line 63

Quoted 1 line
tools/testing/selftests/mm/memorysealing.c new file +1 -0
+     EXPECT_EQ(PROT_READ | PROT_WRITE, prot);

Nitty, but this seems a bit 'Yoda style', that is placing the expectation prior to the value whose expectation we are assessing, that is perhaps it'd be clearer as:

        EXPECT_EQ(prot, PROT_READ | PROT_WRITE);

[resp 3] Both styles are used in self tests and I believe it is equally clear, I can accommodate this request for this patch.

Quoted 3 lines

And again, I think this is really overkill here, if the kernel is unable to do an ordinary mapping correctly we have bigger problems than an mseal bug!

please see [resp 2]

Quoted 7 lines

tools/testing/selftests/mm/memorysealing.c line 67

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+};
+
+FIXTURE_TEARDOWN(basic)
+{

Probably worth adding munmap() teardown here.

please see [resp 1]

Quoted 44 lines
Quoted 33 lines
tools/testing/selftests/mm/memorysealing.c new file +33 -0
+}
+
+FIXTURE(two_vma)
+{
+     unsigned long page_size;
+     unsigned long size;
+     void *ptr;
+};
+
+/*
+ * Setup for two_vma:
+ * Two consecutive VMAs, each with 2 pages.
+ * The first VMA:  prot = PROT_READ.
+ * The second VMA: prot = (PROT_READ | PROT_WRITE).
+ */
+FIXTURE_SETUP(two_vma)
+{
+     int prot;
+     int ret;
+
+     self->page_size = getpagesize();
+
+     if (!mseal_supported())
+             SKIP(return, "mseal is not supported");
+
+     /* Create a single VMA with 4 pages, prot as PROT_READ | PROT_WRITE. */
+     self->size = getpagesize() * 4;
+     self->ptr = setup_single_address(self->size, PROT_READ | PROT_WRITE);
+     EXPECT_NE(self->ptr, MAP_FAILED);
+
+     /* Use mprotect to split as two VMA. */
+     ret = sys_mprotect(self->ptr, self->page_size * 2, PROT_READ);
+     ASSERT_EQ(ret, 0);

tools/testing/selftests/mm/memorysealing.c line 109

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.c new file +9 -0
+
 
+     /* Verify the first VMA is 2 pages and prot bits */
+     EXPECT_EQ(self->page_size * 2, get_vma_size(self->ptr, &prot));
+     EXPECT_EQ(PROT_READ, prot);
+
+     /* Verify the second VMA is 2 pages and prot bits */
+     EXPECT_EQ(self->page_size * 2,
+             get_vma_size(self->ptr + self->page_size * 2, &prot));
+     EXPECT_EQ(PROT_READ | PROT_WRITE, prot);
Quoted 2 lines

Again, as with the prior fixture, it seems a bit overkill, as this is essentially testing 'does mmap() and mprotect()' work. We should hope so :)

Please see [resp 2]

Quoted 7 lines

tools/testing/selftests/mm/memorysealing.c line 113

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+};
+
+FIXTURE_TEARDOWN(two_vma)
+{

Same comment as for the basic fixture - let's clean up after ourselves.

please see [resp 1]

Quoted 22 lines
Quoted 8 lines
tools/testing/selftests/mm/memorysealing.c new file +8 -0
+}
+
+/*
+ * Verify mprotect is blocked.
+ */
+TEST_F(basic, mprotect_basic)
+{
+     int ret;

tools/testing/selftests/mm/memorysealing.c line 131

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.c new file +10 -0
+     unsigned long size;
+     int prot;
+
+     /* Seal the mapping. */
+     ret = sys_mseal(self->ptr, self->size, 0);
+     ASSERT_EQ(ret, 0);
+
+     /* Verify mprotect is blocked. */
+     ret = sys_mprotect(self->ptr, self->size, PROT_READ);
+     EXPECT_GT(0, ret);

Yeah this one is kinda egregious, this is genuinely hard to read. Wouldn't this be better as:

Quoted 7 lines
        EXPECT_NE(ret, 0);

As it explicitly says 'not equal to a success case'. Rather than 'wait 0 is _greater than_ the result which means the result is _less than_ 0 which means an error but let me check the man page can it be positive, oh ok it's -1 on error, 0 on success', which was the Lorenzo thought process... :)

[resp 4] The man page says: "On success, mprotect() and pkey_mprotect() return zero. On error, these system calls return -1, and errno is set to indicate the error."

I wll switch EXPECT_EQ(ret, -1) which is precisely what the man page says.

Quoted 7 lines
Quoted 1 line

+ EXPECT_EQ(EPERM, errno);

Let's invert these, Yoda style isn't really useful here and is a little harder to read, e.g. we should do:

        EXPECT_EQ(errno, EPERM);

please see [resp 3]

Quoted 8 lines

tools/testing/selftests/mm/memorysealing.c line 137

Quoted 5 lines
tools/testing/selftests/mm/memorysealing.c new file +5 -0
+
+     /* Verify the VMA (sealed) isn't changed */
+     size = get_vma_size(self->ptr, &prot);
+     EXPECT_EQ(self->size, size);
+     EXPECT_EQ(PROT_READ | PROT_WRITE, prot);

Again, no to Yoda :)

please see [resp 3]

Quoted 3 lines

I also wonder how useful this is - I guess belts + braces, and linux _can_ do partial failures, but is that something we would care about in practice?

[resp 5]
Those checks will help to detect regression, such as when Pedro Falcato implemented in-loop change [1]. Liam R. Howlett also commented that mseal_test should be extensive enough to check for size and prot to avoid future regression [2]

For your question about partial failure, there will be additional tests for partial-sealed-address range, and those will check the sealed mapping only.

Quoted 11 lines

tools/testing/selftests/mm/memorysealing.c line 144

Quoted 7 lines
tools/testing/selftests/mm/memorysealing.c new file +7 -0
+}
+
+/*
+ * Seal both VMAs in one mseal call.
+ * Verify mprotect is blocked on both VMAs in various cases.
+ */
+TEST_F(two_vma, mprotect)

I'm guessing you aren't necessarily covering _all_ mprotect cases here (though perhaps you intend to later, iteratively?)

Yes.

Quoted 8 lines

tools/testing/selftests/mm/memorysealing.c line 73

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+{
+     int ret;
+     int prot;
+     unsigned long size;

I think 'size' is a bit confusing as it refers to the size ascertained from the get_vma_size() later on. Perhaps call it actual_size?

To help readability, I will change size to vma_size, which corresponds to the return of get_vma_size().

Quoted 10 lines

Maybe worth adding:

        void *ptr = self->ptr;
        unsigned long size = self->size;
        unsigned long page_size = self->page_size;

For convenience?

This is totally optional though, maybe more effort than it's worth.

I don't think it is worth it.

Quoted 5 lines
Quoted 5 lines
tools/testing/selftests/mm/memorysealing.c new file +5 -0
+
+     /* Seal both VMAs in one mseal call. */
+     ret = sys_mseal(self->ptr, self->size, 0);
+     ASSERT_EQ(ret, 0);
+
Quoted 9 lines

tools/testing/selftests/mm/memorysealing.c line 156

Quoted 3 lines
tools/testing/selftests/mm/memorysealing.c new file +3 -0
+     /* Verify mprotect is rejected on the first VMA. */
+     ret = sys_mprotect(self->ptr, self->page_size * 2,
+             PROT_READ | PROT_EXEC);

Why PROT_READ | PROT_EXEC? Is this arbitrary? To be thorough shouldn't you loop through all of the prot flags that you think should fail? And perhaps check what happens if you mprotect() the VMA to set it to what it already is?

[resp 6]
Not arbitrary. As commented in FIXTURE_SETUP, the first VMA is
PROT_READ, and the second VMA is PROT_READ | PROT_WRITE. The test
wants to use mprotect to change the proc bit to a different set.

For your question about mprotect() the sealed vma to what it already is (doesn't change any attribute), I don't want to solidify the current behavior (which is to block). It should be successful instead. With in-loop check and partial update behavior, there is no reason to block it, i.e. no security benefit. I already plan to address this.

Quoted 4 lines
Quoted 1 line

+ EXPECT_GT(0, ret);

Please convert to EXPECT_NE(ret, 0)

please see [resp 4]

Quoted 4 lines
Quoted 1 line

+ EXPECT_EQ(EPERM, errno);

Please invert to EXPECT_EQ(errno, EPERM)

please see [resp 3]

Quoted 10 lines

tools/testing/selftests/mm/memorysealing.c line 162

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+
+     /* Verify mprotect is rejected on the second VMA. */
+     ret = sys_mprotect(self->ptr, self->page_size * 2,
+             PROT_READ | PROT_EXEC);

Hang on, isn't this just a repeat of the first test? Shouldn't this be:

        ret = sys_mprotect(&self->ptr[self->page_size * 2],
                self->page_size * 2, PROT_READ | PROT_EXEC);

[resp 7] Not the same, this test has two VMA, and the mseal() covers both VMAs in one call. In the first test, i.e. basic, mprotect_basic, mseal is called on single VMA.

Quoted 5 lines

tools/testing/selftests/mm/memorysealing.c

Quoted 2 lines
tools/testing/selftests/mm/memorysealing.c new file +2 -0
+     EXPECT_GT(0, ret);
+     EXPECT_EQ(EPERM, errno);

Same comment as above re: ordering.

please see [resp 3]

Quoted 7 lines

tools/testing/selftests/mm/memorysealing.c line 168

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+
+     /* Attempt of mprotect two VMAs at the same call is blocked */
+     ret = sys_mprotect(self->ptr, self->size,
+             PROT_READ | PROT_EXEC);

Same comment about iterating through prot flags that should fail as above.

please see [resp 7]

Quoted 5 lines

tools/testing/selftests/mm/memorysealing.c

Quoted 2 lines
tools/testing/selftests/mm/memorysealing.c new file +2 -0
+     EXPECT_GT(0, ret);
+     EXPECT_EQ(EPERM, errno);

Same comment as above re: ordering.

please see [resp 3]

Quoted 8 lines

tools/testing/selftests/mm/memorysealing.c line 175

Quoted 5 lines
tools/testing/selftests/mm/memorysealing.c new file +5 -0
+
+     /* Verify both VMAs aren't changed. */
+     size = get_vma_size(self->ptr, &prot);
+     EXPECT_EQ(self->page_size * 2, size);
+     EXPECT_EQ(PROT_READ, prot);

Same comment as above re: ordering.

please see [resp 3]

Quoted 7 lines

tools/testing/selftests/mm/memorysealing.c line 179

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+
+     size = get_vma_size(self->ptr + self->page_size * 2, &prot);
+     EXPECT_EQ(self->page_size * 2, size);
+     EXPECT_EQ(PROT_READ | PROT_WRITE, prot);

Same comment as above re: ordering.

please see [resp 3]

Quoted 11 lines
Quoted 11 lines
tools/testing/selftests/mm/memorysealing.c new file +3 -0
+}
+
+TEST_HARNESS_MAIN
tools/testing/selftests/mm/memorysealing.h new file +2 -0
new file mode 100644
index 000000000000..aee6e6700028
@@ -0,0 +1,116 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#include <syscall.h>
Quoted 9 lines

tools/testing/selftests/mm/memorysealing.h line 7

Quoted 5 lines
tools/testing/selftests/mm/memorysealing.h new file +5 -0
+
+/*
+ * Define sys_xyx to call syscall directly.
+ * This is needed because we want to avoid calling glibc and
+ * test syscall directly.

I do wonder if this is worth it, but I mean, I guess it's not too egregious if it's wrapped like this. Same comment for other wrappers.

The self-test should directly test the kernel syscall without any intermediate layer. selftest is not a libc test. It is practical too, glibc's behavior can change across versions which result inconsistent, and Padro Falcato reported one of this and fixed in [3]

Quoted 11 lines

tools/testing/selftests/mm/memorysealing.h line 15

Quoted 8 lines
tools/testing/selftests/mm/memorysealing.h new file +8 -0
+ * The only exception is mmap, which _NR_mmap2 is not defined for
+ * some ARM architecture.
+ */
+static inline int sys_mseal(void *start, size_t len, unsigned long flags)
+{
+     int sret;
+
+     errno = 0;

Why are we setting this to 0? Same comment for all sys_XXX() wrappers.

The test is only interested in the latest error associated with the failed syscall, and I'm not sure the kernel clears the errno for each system call. Note, there is no glibc layer here.

Quoted 10 lines

tools/testing/selftests/mm/memorysealing.h line 17

Quoted 2 lines
tools/testing/selftests/mm/memorysealing.h new file +2 -0
+     sret = syscall(__NR_mseal, start, len, flags);
+     return sret;

Nit, but this seems a bit redundant, why not just drop the sret assignment, and simply:

        return syscall(__NR_mseal, start, len, flags);

Same comment for all sys_XXX() wrappers.

[resp 6] I think this is a different taste in coding style. For the test, I prefer to have local variables so it is easy to show them in the debugger, when needed.

Quoted 6 lines
Quoted 6 lines
tools/testing/selftests/mm/memorysealing.h new file +6 -0
+}
+
+static inline int sys_mprotect(void *ptr, size_t size, unsigned long prot)
+{
+     int sret;
+
Quoted 9 lines

tools/testing/selftests/mm/memorysealing.h line 28

Quoted 5 lines
tools/testing/selftests/mm/memorysealing.h new file +5 -0
+     errno = 0;
+     sret = syscall(__NR_mprotect, ptr, size, prot);
+     return sret;
+}
+

The wrappers below don't seem to be used yet, could we delay putting them in until they are actually used?

Sure, I will remove sys_mprotect_pkey for this patch.

Quoted 50 lines
Quoted 37 lines
tools/testing/selftests/mm/memorysealing.h new file +37 -0
+static inline int sys_mprotect_pkey(void *ptr, size_t size,
+     unsigned long orig_prot, unsigned long pkey)
+{
+     int sret;
+
+     errno = 0;
+     sret = syscall(__NR_pkey_mprotect, ptr, size, orig_prot, pkey);
+     return sret;
+}
+
+static inline int sys_munmap(void *ptr, size_t size)
+{
+     int sret;
+
+     errno = 0;
+     sret = syscall(__NR_munmap, ptr, size);
+     return sret;
+}
+
+static inline int sys_madvise(void *start, size_t len, int types)
+{
+     int sret;
+
+     errno = 0;
+     sret = syscall(__NR_madvise, start, len, types);
+     return sret;
+}
+
+static inline void *sys_mremap(void *addr, size_t old_len, size_t new_len,
+     unsigned long flags, void *new_addr)
+{
+     void *sret;
+
+     errno = 0;
+     sret = (void *) syscall(__NR_mremap, addr, old_len, new_len, flags, new_addr);
+     return sret;
+}

tools/testing/selftests/mm/memorysealing.h line 75

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.h new file +10 -0
+
+/*
+ * Parsing /proc/self/maps to get VMA's size and prot bit.
+ */
+static unsigned long get_vma_size(void *addr, int *prot)
+{
+     FILE *maps;
+     char line[256];
+     int size = 0;
+     uintptr_t  addr_start, addr_end;

Why not add a:

Quoted 4 lines
        uintptr_t addr_val = (uintptr_t)addr;

To avoid having to constantly cast below?

sure.

Quoted 8 lines

tools/testing/selftests/mm/memorysealing.h line 77

Quoted 2 lines
tools/testing/selftests/mm/memorysealing.h new file +2 -0
+     char protstr[5];
+     *prot = 0;

Nit but not sure there's much point in setting this to 0 even in failure cases?

With an error code return you can avoid having to do this.

[resp 8]
I don't think the error code return is worth the effort, it currently returns 0 size in case of error or not-found. For easy debug parsing errors, I can add logs. Notes, the parsing should always be successful.

Quoted 9 lines

tools/testing/selftests/mm/memorysealing.h line 81

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.h new file +4 -0
+
+     maps = fopen("/proc/self/maps", "r");
+     if (!maps)
+             return 0;

Might it be better to return an error code or something so we can identify this case? I guess any sensible call will fail on a 0 but you're sort of just implicitly hoping for this.

[resp 9] we could add logging in case of error.

Quoted 10 lines

tools/testing/selftests/mm/memorysealing.h line 85

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.h new file +4 -0
+
+     while (fgets(line, sizeof(line), maps)) {
+             if (sscanf(line, "%lx-%lx %4s", &addr_start, &addr_end, protstr) == 3) {
+                     if (addr_start == (uintptr_t) addr) {

This is a Yoda comparison again, let's put what we're comparing first, and the thing we're comparing to afterwards, e.g.

        if ((uintptr_t)addr == addr_start) ...

addr is the expected value from input and addr_start changes after parsing each line. The expected value (addr) is in second position, why is this yoda syntax ? IMO, introducing the yoda syntax concept for "==" is more confusing than useful, A==B is as clear as B==A.

Quoted 2 lines

Also I don't think a space after the (type) cast is necesary.

sure

Quoted 31 lines

tools/testing/selftests/mm/memorysealing.h line 96

Quoted 11 lines
tools/testing/selftests/mm/memorysealing.h new file +11 -0
+                             size = addr_end - addr_start;
+                             if (protstr[0] == 'r')
+                                     *prot |= PROT_READ;
+                             if (protstr[1] == 'w')
+                                     *prot |= PROT_WRITE;
+                             if (protstr[2] == 'x')
+                                     *prot |= PROT_EXEC;
+                             break;
+                     }
+             }
+     }

On the impl: This would be neater if you used guard clauses:

        while (fgets(line, sizeof(line), maps)) {
                if (sscanf(line, "%lx-%lx %4s", &addr_start, &addr_end, protstr) != 3)
                        continue;

                if (addr_val != addr_start)
                        continue;

                size = addr_end - addr_start;
                if (protstr[0] == 'r')
                        *prot |= PROT_READ;
                if (protstr[1] == 'w')
                        *prot |= PROT_WRITE;
                if (protstr[2] == 'x')
                        *prot |= PROT_EXEC;
                break;
        }
Quoted 2 lines

This is a lot more readable?

sure.

Quoted 8 lines

On doing this at all - it feels a bit crazy to check this, but I guess it might be the only way to assert things about merge/split.

I'm not sure it's _really useful_ to do that though - merges/splits are internal implementation details in effect (modulo mremap single VMA requirements), and mseal is an external interface, really the check should be around 'can forbidden operations be performed on sealed mappings'.

This is related to resp [5].
This test not only verifies the size, but also verifies the prot bits. The argument that VMA is an internal behavior is questionable, the /proc/pid/maps is user-facing and applications can read it and parse it.

Quoted 6 lines

However, if you do really want to do this, I think it would be much better to use the new ioctl interface for this [0] which should avoid having to do unpleasant text wrangling :)

[0]:https://lore.kernel.org/all/[email protected]/

I could try this. This is a new feature though, I do think this selftest should be self-standing and has as minimal dependency as possible. Is there harm of using /proc/pid/maps ? parsing /proc/pid/maps already used by selftest in lots of places (see below), I would prefer testing to use well-established patterns than relying on a newly developed feature.

filesystems/overlayfs/dev_in_maps.c
mm/mlock2-tests.c
mm/mremap_test.c
mm/virtual_address_range.c
mm/split_huge_page_test.c
filesystems/overlayfs/dev_in_maps.c
exec/load_address.c
bpf/trace_helpers.c

Quoted 7 lines

tools/testing/selftests/mm/memorysealing.h line 98

Quoted 3 lines
tools/testing/selftests/mm/memorysealing.h new file +2 -0
+     fclose(maps);
+     return size;

If we don't find the line we don't seem to be indicating this, again worth being able to pass back an error?

It can be normal that we don't find a line, i.e. tests want to verify that a VMA does not exist at address, return 0 size is correct in this case. If a parsing error ever happened, the test would have failed at FIXTURE_SETUP to begin with.

Quoted 19 lines
Quoted 5 lines
tools/testing/selftests/mm/memorysealing.h new file +5 -0
+}
+
+static inline bool mseal_supported(void)
+{
+     int ret;

tools/testing/selftests/mm/memorysealing.h line 113

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.h new file +10 -0
+     void *ptr;
+     unsigned long page_size = getpagesize();
+
+     ptr = mmap(NULL, page_size, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+     if (ptr == MAP_FAILED)
+             return false;
+
+     ret = sys_mseal(ptr, page_size, 0);
+     if (ret < 0)
+             return false;

This is kind of cute, I mean it speaks to the need I think for us to be able to expose 'is X available?' programmatically. But I digress.

Quoted 2 lines

I guess this is ok, as this is something that should never fail.

You might recall that mseal is not available on the 32 bits kernel, automation might run the mseal_test on a 32 bit build. mseal_supported() detects this so tests can be skipped.

Quoted 3 lines

But we should definitely clean up after ourselves here whether this succeeds or fails.

please see resp [1].

Thanks!
-Jeff
[1] https://lore.kernel.org/all/CAKbZUD31EK2ah=vWJ46y4nL9OygzAa6ZxPnPHmWYO-sop5t+5Q@mail.gmail.com/
[2] https://lore.kernel.org/all/ko3pjllsgufbz33hqvwdpdsyxvgrgzqiodxexnpcng3mssffeh@dfgfkqlg46xa/
[3] https://lore.kernel.org/all/[email protected]/

Quoted 112 lines
Quoted 112 lines
tools/testing/selftests/mm/memorysealing.h new file +3 -0
+
+     return true;
+}
tools/testing/selftests/mm/mseal_test.c +1 -67
index ad17005521a8..8dd20341de3d 100644
@@ -517,30 +517,6 @@ static void test_seal_twice(void)
      REPORT_TEST_PASS();
 }
 
-static void test_seal_mprotect(bool seal)
-{
-     void *ptr;
-     unsigned long page_size = getpagesize();
-     unsigned long size = 4 * page_size;
-     int ret;
-
-     setup_single_address(size, &ptr);
-     FAIL_TEST_IF_FALSE(ptr != (void *)-1);
-
-     if (seal) {
-             ret = seal_single_address(ptr, size);
-             FAIL_TEST_IF_FALSE(!ret);
-     }
-
-     ret = sys_mprotect(ptr, size, PROT_READ | PROT_WRITE);
-     if (seal)
-             FAIL_TEST_IF_FALSE(ret < 0);
-     else
-             FAIL_TEST_IF_FALSE(!ret);
-
-     REPORT_TEST_PASS();
-}
-
 static void test_seal_start_mprotect(bool seal)
 {
      void *ptr;
@@ -658,41 +634,6 @@ static void test_seal_mprotect_unalign_len_variant_2(bool seal)
      REPORT_TEST_PASS();
 }
 
-static void test_seal_mprotect_two_vma(bool seal)
-{
-     void *ptr;
-     unsigned long page_size = getpagesize();
-     unsigned long size = 4 * page_size;
-     int ret;
-
-     setup_single_address(size, &ptr);
-     FAIL_TEST_IF_FALSE(ptr != (void *)-1);
-
-     /* use mprotect to split */
-     ret = sys_mprotect(ptr, page_size * 2, PROT_READ | PROT_WRITE);
-     FAIL_TEST_IF_FALSE(!ret);
-
-     if (seal) {
-             ret = seal_single_address(ptr, page_size * 4);
-             FAIL_TEST_IF_FALSE(!ret);
-     }
-
-     ret = sys_mprotect(ptr, page_size * 2, PROT_READ | PROT_WRITE);
-     if (seal)
-             FAIL_TEST_IF_FALSE(ret < 0);
-     else
-             FAIL_TEST_IF_FALSE(!ret);
-
-     ret = sys_mprotect(ptr + page_size * 2, page_size * 2,
-                     PROT_READ | PROT_WRITE);
-     if (seal)
-             FAIL_TEST_IF_FALSE(ret < 0);
-     else
-             FAIL_TEST_IF_FALSE(!ret);
-
-     REPORT_TEST_PASS();
-}
-
 static void test_seal_mprotect_two_vma_with_split(bool seal)
 {
      void *ptr;
@@ -1876,7 +1817,7 @@ int main(void)
      if (!pkey_supported())
              ksft_print_msg("PKEY not supported\n");
 
-     ksft_set_plan(88);
+     ksft_set_plan(84);
 
      test_seal_addseal();
      test_seal_unmapped_start();
@@ -1889,9 +1830,6 @@ int main(void)
      test_seal_zero_length();
      test_seal_twice();
 
-     test_seal_mprotect(false);
-     test_seal_mprotect(true);
-
      test_seal_start_mprotect(false);
      test_seal_start_mprotect(true);
 
@@ -1904,9 +1842,6 @@ int main(void)
      test_seal_mprotect_unalign_len_variant_2(false);
      test_seal_mprotect_unalign_len_variant_2(true);
 
-     test_seal_mprotect_two_vma(false);
-     test_seal_mprotect_two_vma(true);
-
      test_seal_mprotect_two_vma_with_split(false);
      test_seal_mprotect_two_vma_with_split(true);
 
--

2.47.1.613.gc27f4b7a9f-goog

author
#4 lore raw

Re: [RFC PATCH v1 1/1] selftest/mm: refactor mseal_test

Hi Lorenzo,

Gentle ping for my clarification questions.

I also tried the new ioctl PROCMAP_QUERY, please see below for details.

Quoted 756 lines · Jeff Xu

Hi Lorenzo,

Quoted 4 lines · Lorenzo Stoakes

Sorry for delay, was super busy leading up to xmas break, then had ~2.5 weeks off.

Thanks for reviewing. There are lots of comments, so it takes some time to go through comments and experiment with some of the suggested changes. Please see below.

Quoted 2 lines

And happy new year! :)

Happy new year !

Quoted 10 lines · On Wed, Dec 11, 2024 at 05:33:11AM +0000, [email protected] wrote:
Quoted 5 lines

From: Jeff Xu <[email protected]>

This change creates the initial version of memorysealing.c.

The introduction of memorysealing.c, which replaces mseal_test.c and

I mean I don't want to be a pain but I would kinda prefer to have 'mseal' everywhere mseal is to avoid confusion vs. memfd seals.

As I tried to explain, the memorysealing.c will eventually replace mseal_test.c, after all the tests are moved to use kselftest_karness. How about mseal_test_new.c ? I'm open to new names if you have one.

Quoted 11 lines

Of course we in the kernel absolutely _love_ to overload the meaning of terms but some traditions are worth breaking :)

Quoted 4 lines

uses the kselftest_harness, aims to initiate a discussion on using the selftest harness for memory sealing tests. Upon approval of this approach, the migration of tests from mseal_test.c to memorysealing.c can be implemented in a step-by-step manner.

Well, I for one like this approach so (unsurprisingly) :) but perhaps sensible to do it iteratively so we can also tweak things as we go.

Yes, that is the idea.

Quoted 85 lines
Quoted 7 lines

This tests addresses following feedback from previous reviews:

1> Use kselftest_harness instead of custom macro, such as EXPECT_XX, ASSERT_XX, etc. (Lorenzo Stoakes, Mark Brown) [1]

2> Use MAP_FAILED to check the return of mmap (Lorenzo Stoakes).

Thanks!

Quoted 75 lines

3> Adding a check for vma size and prot bits. The discussion for
this can be found in [2] [3], here is a brief summary:
This is to follow up on Pedro’s in-loop change (from can_modify_mm to can_modify_vma). When mseal_test is initially created, they have a common pattern: setup memory layout, seal the memory, perform a few mm-api steps, verify return code (not zero). Because of the nature of out-of-loop, it is sufficient to just verify the error code in a few cases.

With Pedro's in-loop change, the sealing check happens later in the stack, thus there are more things and scenarios to verify. And there was feedbacks to me that mseal_test should be extensive enough to discover all regressions. Hence I'm adding check for vma size and prot bits.

In this change: we created two fixtures:

Fixture basic: This creates a single VMA, the VMA has a
PROT_NONE page at each end to prevent auto-merging.

Fixture wo_vma: Two VMAs back to end, a PROT_NONE page at each end to prevent auto-merging.

In addition, I add one test (mprotec) in each fixture to demo the tests.

[1] https://lore.kernel.org/all/[email protected]/
[2] https://lore.kernel.org/all/CABi2SkUgDZtJtRJe+J9UNdtZn=EQzZcbMB685P=1rR7DUhg=6Q@mail.gmail.com/
[3] https://lore.kernel.org/all/2qywbjb5ebtgwkh354w3lj3vhaothvubjokxq5fhyri5jeeton@duqngzo3swjz/

---
 tools/testing/selftests/mm/.gitignore      |   1 +
 tools/testing/selftests/mm/Makefile        |   1 +
 tools/testing/selftests/mm/memorysealing.c | 182 +++++++++++++++++++++
 tools/testing/selftests/mm/memorysealing.h | 116 +++++++++++++
 tools/testing/selftests/mm/mseal_test.c    |  67 +-------
 5 files changed, 301 insertions(+), 66 deletions(-)
 create mode 100644 tools/testing/selftests/mm/memorysealing.c
 create mode 100644 tools/testing/selftests/mm/memorysealing.h
tools/testing/selftests/mm/.gitignore +1 -0
index a51a947b2d1d..982234a99f20 100644
@@ -57,3 +57,4 @@ hugetlb_dio
 pkey_sighandler_tests_32
 pkey_sighandler_tests_64
 guard-pages
+memorysealing
tools/testing/selftests/mm/Makefile +1 -0
index 93a46ac633df..08876624f46d 100644
@@ -67,6 +67,7 @@ TEST_GEN_FILES += map_populate
 ifneq (,$(filter $(ARCH),arm64 riscv riscv64 x86 x86_64))
 TEST_GEN_FILES += memfd_secret
 endif
+TEST_GEN_FILES += memorysealing
 TEST_GEN_FILES += migration
 TEST_GEN_FILES += mkdirty
 TEST_GEN_FILES += mlock-random-test
tools/testing/selftests/mm/memorysealing.c new file +7 -0
new file mode 100644
index 000000000000..e10032528b64
@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#define _GNU_SOURCE
+#include "../kselftest_harness.h"
+#include <asm-generic/unistd.h>
+#include <errno.h>
+#include <syscall.h>
+#include "memorysealing.h"
Quoted 9 lines

tools/testing/selftests/mm/memorysealing.c line 13

Quoted 6 lines
tools/testing/selftests/mm/memorysealing.c new file +6 -0
+
+/*
+ * To avoid auto-merging, create a VMA with PROT_NONE pages at each end.
+ * If unsuccessful, return MAP_FAILED.
+ */
+static void *setup_single_address(int size, int prot)

Nitty, but size should really be an unsigned long.

sure, thanks

Quoted 8 lines

tools/testing/selftests/mm/memorysealing.c line 17

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+{
+     int ret;
+     void *ptr;
+     unsigned long page_size = getpagesize();

Trivial, but we store page size in self->page_size so why not pass it as a parameter instead of looking up?

sure.

Quoted 21 lines
Quoted 8 lines
tools/testing/selftests/mm/memorysealing.c new file +8 -0
+
+     ptr = mmap(NULL, size + 2 * page_size, prot,
+             MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+
+     if (ptr == MAP_FAILED)
+             return MAP_FAILED;
+
+     /* To avoid auto-merging, change to PROT_NONE at each end. */

tools/testing/selftests/mm/memorysealing.c line 35

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.c new file +10 -0
+     ret = sys_mprotect(ptr, page_size, PROT_NONE);
+     if (ret != 0)
+             return MAP_FAILED;
+
+     ret = sys_mprotect(ptr + size + page_size, page_size, PROT_NONE);
+     if (ret != 0)
+             return MAP_FAILED;
+
+     return ptr + page_size;
+}

This could be done more easily with a single PROT_NONE, like:

Quoted 15 lines
        static void *setup_single_address(unsigned long size, int prot,
                        unsigned long page_size)
        {
                void *ptr;

                /* Ensure we only merge what we intend to. */
                ptr = mmap(NULL, size + 2 * page_size, PROT_NONE,
                           MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
                if (ptr == MAP_FAILED)
                        return MAP_FAILED;

                return mmap(&ptr[page_size], size, prot,
                            MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
        }

sure, create PROT_NONE mapping first, then use mprotect to change the middle part.

Quoted 7 lines

It's probably worth having an equivalent freeing function to avoid leaks:

        static int free_single_address(void *ptr, unsigned long size,
                        unsigned long page_size)
        {
                /* Also free the PROT_NONE sentinels. */
                return munmap(ptr - page_size, size + 2 * page_size);

[resp 1] could you clarify? I think we won't need freeing because mapping will be sealed. You might recall, mseal() blocks munmap(), and munmap() is atomic, so the above line that you suggested will result in no-action during FIXTURE_TEARDOWN. There will be separate test cases to test munmap under sealing. In addition, the virtual address space is big enough for this test complete without worry about the out-of-memory situation. Do I miss anything ?

Quoted 24 lines
        }
Quoted 22 lines
tools/testing/selftests/mm/memorysealing.c new file +22 -0
+
+FIXTURE(basic)
+{
+     unsigned long page_size;
+     unsigned long size;
+     void *ptr;
+};
+
+/*
+ * Setup for basic:
+ * Single VMA with 4 pages, prot = (PROT_READ | PROT_WRITE).
+ */
+FIXTURE_SETUP(basic)
+{
+     int prot;
+
+     self->page_size = getpagesize();
+
+     if (!mseal_supported())
+             SKIP(return, "mseal is not supported");
+
+     /* Create a single VMA with 4 pages, prot as PROT_READ | PROT_WRITE. */
Quoted 9 lines

tools/testing/selftests/mm/memorysealing.c line 62

Quoted 5 lines
tools/testing/selftests/mm/memorysealing.c new file +5 -0
+     self->size = self->page_size * 4;
+     self->ptr = setup_single_address(self->size, PROT_READ | PROT_WRITE);
+     EXPECT_NE(self->ptr, MAP_FAILED);
+
+     EXPECT_EQ(self->size, get_vma_size(self->ptr, &prot));

I mean fine but this check seems a bit overkill here, we don't need to check to ensure that PROT_NONE works.

[resp 2] Those checks are there, for the same reason that test cases usually check the return value of mmap(), mprotect() in the FIXTURE_SETUP. You are right that those calls are unlikely to fail, however, test cases generally do those "housekeeping tasks" to make sure everything is OK before the actual test. If you don't want to keep those, what is the downside of keeping them ?

Quoted 8 lines

tools/testing/selftests/mm/memorysealing.c line 63

Quoted 1 line
tools/testing/selftests/mm/memorysealing.c new file +1 -0
+     EXPECT_EQ(PROT_READ | PROT_WRITE, prot);

Nitty, but this seems a bit 'Yoda style', that is placing the expectation prior to the value whose expectation we are assessing, that is perhaps it'd be clearer as:

        EXPECT_EQ(prot, PROT_READ | PROT_WRITE);

[resp 3] Both styles are used in self tests and I believe it is equally clear, I can accommodate this request for this patch.

Quoted 3 lines

And again, I think this is really overkill here, if the kernel is unable to do an ordinary mapping correctly we have bigger problems than an mseal bug!

please see [resp 2]

Quoted 7 lines

tools/testing/selftests/mm/memorysealing.c line 67

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+};
+
+FIXTURE_TEARDOWN(basic)
+{

Probably worth adding munmap() teardown here.

please see [resp 1]

Quoted 44 lines
Quoted 33 lines
tools/testing/selftests/mm/memorysealing.c new file +33 -0
+}
+
+FIXTURE(two_vma)
+{
+     unsigned long page_size;
+     unsigned long size;
+     void *ptr;
+};
+
+/*
+ * Setup for two_vma:
+ * Two consecutive VMAs, each with 2 pages.
+ * The first VMA:  prot = PROT_READ.
+ * The second VMA: prot = (PROT_READ | PROT_WRITE).
+ */
+FIXTURE_SETUP(two_vma)
+{
+     int prot;
+     int ret;
+
+     self->page_size = getpagesize();
+
+     if (!mseal_supported())
+             SKIP(return, "mseal is not supported");
+
+     /* Create a single VMA with 4 pages, prot as PROT_READ | PROT_WRITE. */
+     self->size = getpagesize() * 4;
+     self->ptr = setup_single_address(self->size, PROT_READ | PROT_WRITE);
+     EXPECT_NE(self->ptr, MAP_FAILED);
+
+     /* Use mprotect to split as two VMA. */
+     ret = sys_mprotect(self->ptr, self->page_size * 2, PROT_READ);
+     ASSERT_EQ(ret, 0);

tools/testing/selftests/mm/memorysealing.c line 109

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.c new file +9 -0
+
 
+     /* Verify the first VMA is 2 pages and prot bits */
+     EXPECT_EQ(self->page_size * 2, get_vma_size(self->ptr, &prot));
+     EXPECT_EQ(PROT_READ, prot);
+
+     /* Verify the second VMA is 2 pages and prot bits */
+     EXPECT_EQ(self->page_size * 2,
+             get_vma_size(self->ptr + self->page_size * 2, &prot));
+     EXPECT_EQ(PROT_READ | PROT_WRITE, prot);
Quoted 2 lines

Again, as with the prior fixture, it seems a bit overkill, as this is essentially testing 'does mmap() and mprotect()' work. We should hope so :)

Please see [resp 2]

Quoted 7 lines

tools/testing/selftests/mm/memorysealing.c line 113

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+};
+
+FIXTURE_TEARDOWN(two_vma)
+{

Same comment as for the basic fixture - let's clean up after ourselves.

please see [resp 1]

Quoted 22 lines
Quoted 8 lines
tools/testing/selftests/mm/memorysealing.c new file +8 -0
+}
+
+/*
+ * Verify mprotect is blocked.
+ */
+TEST_F(basic, mprotect_basic)
+{
+     int ret;

tools/testing/selftests/mm/memorysealing.c line 131

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.c new file +10 -0
+     unsigned long size;
+     int prot;
+
+     /* Seal the mapping. */
+     ret = sys_mseal(self->ptr, self->size, 0);
+     ASSERT_EQ(ret, 0);
+
+     /* Verify mprotect is blocked. */
+     ret = sys_mprotect(self->ptr, self->size, PROT_READ);
+     EXPECT_GT(0, ret);

Yeah this one is kinda egregious, this is genuinely hard to read. Wouldn't this be better as:

Quoted 7 lines
        EXPECT_NE(ret, 0);

As it explicitly says 'not equal to a success case'. Rather than 'wait 0 is _greater than_ the result which means the result is _less than_ 0 which means an error but let me check the man page can it be positive, oh ok it's -1 on error, 0 on success', which was the Lorenzo thought process... :)

[resp 4] The man page says: "On success, mprotect() and pkey_mprotect() return zero. On error, these system calls return -1, and errno is set to indicate the error."

I wll switch EXPECT_EQ(ret, -1) which is precisely what the man page says.

Quoted 7 lines
Quoted 1 line

+ EXPECT_EQ(EPERM, errno);

Let's invert these, Yoda style isn't really useful here and is a little harder to read, e.g. we should do:

        EXPECT_EQ(errno, EPERM);

please see [resp 3]

Quoted 8 lines

tools/testing/selftests/mm/memorysealing.c line 137

Quoted 5 lines
tools/testing/selftests/mm/memorysealing.c new file +5 -0
+
+     /* Verify the VMA (sealed) isn't changed */
+     size = get_vma_size(self->ptr, &prot);
+     EXPECT_EQ(self->size, size);
+     EXPECT_EQ(PROT_READ | PROT_WRITE, prot);

Again, no to Yoda :)

please see [resp 3]

Quoted 3 lines

I also wonder how useful this is - I guess belts + braces, and linux _can_ do partial failures, but is that something we would care about in practice?

[resp 5]
Those checks will help to detect regression, such as when Pedro Falcato implemented in-loop change [1]. Liam R. Howlett also commented that mseal_test should be extensive enough to check for size and prot to avoid future regression [2]

For your question about partial failure, there will be additional tests for partial-sealed-address range, and those will check the sealed mapping only.

Quoted 11 lines

tools/testing/selftests/mm/memorysealing.c line 144

Quoted 7 lines
tools/testing/selftests/mm/memorysealing.c new file +7 -0
+}
+
+/*
+ * Seal both VMAs in one mseal call.
+ * Verify mprotect is blocked on both VMAs in various cases.
+ */
+TEST_F(two_vma, mprotect)

I'm guessing you aren't necessarily covering _all_ mprotect cases here (though perhaps you intend to later, iteratively?)

Yes.

Quoted 8 lines

tools/testing/selftests/mm/memorysealing.c line 73

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+{
+     int ret;
+     int prot;
+     unsigned long size;

I think 'size' is a bit confusing as it refers to the size ascertained from the get_vma_size() later on. Perhaps call it actual_size?

To help readability, I will change size to vma_size, which corresponds to the return of get_vma_size().

Quoted 10 lines

Maybe worth adding:

        void *ptr = self->ptr;
        unsigned long size = self->size;
        unsigned long page_size = self->page_size;

For convenience?

This is totally optional though, maybe more effort than it's worth.

I don't think it is worth it.

Quoted 5 lines
Quoted 5 lines
tools/testing/selftests/mm/memorysealing.c new file +5 -0
+
+     /* Seal both VMAs in one mseal call. */
+     ret = sys_mseal(self->ptr, self->size, 0);
+     ASSERT_EQ(ret, 0);
+
Quoted 9 lines

tools/testing/selftests/mm/memorysealing.c line 156

Quoted 3 lines
tools/testing/selftests/mm/memorysealing.c new file +3 -0
+     /* Verify mprotect is rejected on the first VMA. */
+     ret = sys_mprotect(self->ptr, self->page_size * 2,
+             PROT_READ | PROT_EXEC);

Why PROT_READ | PROT_EXEC? Is this arbitrary? To be thorough shouldn't you loop through all of the prot flags that you think should fail? And perhaps check what happens if you mprotect() the VMA to set it to what it already is?

[resp 6]
Not arbitrary. As commented in FIXTURE_SETUP, the first VMA is
PROT_READ, and the second VMA is PROT_READ | PROT_WRITE. The test
wants to use mprotect to change the proc bit to a different set.

For your question about mprotect() the sealed vma to what it already is (doesn't change any attribute), I don't want to solidify the current behavior (which is to block). It should be successful instead. With in-loop check and partial update behavior, there is no reason to block it, i.e. no security benefit. I already plan to address this.

Quoted 4 lines
Quoted 1 line

+ EXPECT_GT(0, ret);

Please convert to EXPECT_NE(ret, 0)

please see [resp 4]

Quoted 4 lines
Quoted 1 line

+ EXPECT_EQ(EPERM, errno);

Please invert to EXPECT_EQ(errno, EPERM)

please see [resp 3]

Quoted 10 lines

tools/testing/selftests/mm/memorysealing.c line 162

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+
+     /* Verify mprotect is rejected on the second VMA. */
+     ret = sys_mprotect(self->ptr, self->page_size * 2,
+             PROT_READ | PROT_EXEC);

Hang on, isn't this just a repeat of the first test? Shouldn't this be:

        ret = sys_mprotect(&self->ptr[self->page_size * 2],
                self->page_size * 2, PROT_READ | PROT_EXEC);

[resp 7] Not the same, this test has two VMA, and the mseal() covers both VMAs in one call. In the first test, i.e. basic, mprotect_basic, mseal is called on single VMA.

Quoted 5 lines

tools/testing/selftests/mm/memorysealing.c

Quoted 2 lines
tools/testing/selftests/mm/memorysealing.c new file +2 -0
+     EXPECT_GT(0, ret);
+     EXPECT_EQ(EPERM, errno);

Same comment as above re: ordering.

please see [resp 3]

Quoted 7 lines

tools/testing/selftests/mm/memorysealing.c line 168

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+
+     /* Attempt of mprotect two VMAs at the same call is blocked */
+     ret = sys_mprotect(self->ptr, self->size,
+             PROT_READ | PROT_EXEC);

Same comment about iterating through prot flags that should fail as above.

please see [resp 7]

Quoted 5 lines

tools/testing/selftests/mm/memorysealing.c

Quoted 2 lines
tools/testing/selftests/mm/memorysealing.c new file +2 -0
+     EXPECT_GT(0, ret);
+     EXPECT_EQ(EPERM, errno);

Same comment as above re: ordering.

please see [resp 3]

Quoted 8 lines

tools/testing/selftests/mm/memorysealing.c line 175

Quoted 5 lines
tools/testing/selftests/mm/memorysealing.c new file +5 -0
+
+     /* Verify both VMAs aren't changed. */
+     size = get_vma_size(self->ptr, &prot);
+     EXPECT_EQ(self->page_size * 2, size);
+     EXPECT_EQ(PROT_READ, prot);

Same comment as above re: ordering.

please see [resp 3]

Quoted 7 lines

tools/testing/selftests/mm/memorysealing.c line 179

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+
+     size = get_vma_size(self->ptr + self->page_size * 2, &prot);
+     EXPECT_EQ(self->page_size * 2, size);
+     EXPECT_EQ(PROT_READ | PROT_WRITE, prot);

Same comment as above re: ordering.

please see [resp 3]

Quoted 11 lines
Quoted 11 lines
tools/testing/selftests/mm/memorysealing.c new file +3 -0
+}
+
+TEST_HARNESS_MAIN
tools/testing/selftests/mm/memorysealing.h new file +2 -0
new file mode 100644
index 000000000000..aee6e6700028
@@ -0,0 +1,116 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#include <syscall.h>
Quoted 9 lines

tools/testing/selftests/mm/memorysealing.h line 7

Quoted 5 lines
tools/testing/selftests/mm/memorysealing.h new file +5 -0
+
+/*
+ * Define sys_xyx to call syscall directly.
+ * This is needed because we want to avoid calling glibc and
+ * test syscall directly.

I do wonder if this is worth it, but I mean, I guess it's not too egregious if it's wrapped like this. Same comment for other wrappers.

The self-test should directly test the kernel syscall without any intermediate layer. selftest is not a libc test. It is practical too, glibc's behavior can change across versions which result inconsistent, and Padro Falcato reported one of this and fixed in [3]

Quoted 11 lines

tools/testing/selftests/mm/memorysealing.h line 15

Quoted 8 lines
tools/testing/selftests/mm/memorysealing.h new file +8 -0
+ * The only exception is mmap, which _NR_mmap2 is not defined for
+ * some ARM architecture.
+ */
+static inline int sys_mseal(void *start, size_t len, unsigned long flags)
+{
+     int sret;
+
+     errno = 0;

Why are we setting this to 0? Same comment for all sys_XXX() wrappers.

The test is only interested in the latest error associated with the failed syscall, and I'm not sure the kernel clears the errno for each system call. Note, there is no glibc layer here.

Quoted 10 lines

tools/testing/selftests/mm/memorysealing.h line 17

Quoted 2 lines
tools/testing/selftests/mm/memorysealing.h new file +2 -0
+     sret = syscall(__NR_mseal, start, len, flags);
+     return sret;

Nit, but this seems a bit redundant, why not just drop the sret assignment, and simply:

        return syscall(__NR_mseal, start, len, flags);

Same comment for all sys_XXX() wrappers.

[resp 6] I think this is a different taste in coding style. For the test, I prefer to have local variables so it is easy to show them in the debugger, when needed.

Quoted 6 lines
Quoted 6 lines
tools/testing/selftests/mm/memorysealing.h new file +6 -0
+}
+
+static inline int sys_mprotect(void *ptr, size_t size, unsigned long prot)
+{
+     int sret;
+
Quoted 9 lines

tools/testing/selftests/mm/memorysealing.h line 28

Quoted 5 lines
tools/testing/selftests/mm/memorysealing.h new file +5 -0
+     errno = 0;
+     sret = syscall(__NR_mprotect, ptr, size, prot);
+     return sret;
+}
+

The wrappers below don't seem to be used yet, could we delay putting them in until they are actually used?

Sure, I will remove sys_mprotect_pkey for this patch.

Quoted 50 lines
Quoted 37 lines
tools/testing/selftests/mm/memorysealing.h new file +37 -0
+static inline int sys_mprotect_pkey(void *ptr, size_t size,
+     unsigned long orig_prot, unsigned long pkey)
+{
+     int sret;
+
+     errno = 0;
+     sret = syscall(__NR_pkey_mprotect, ptr, size, orig_prot, pkey);
+     return sret;
+}
+
+static inline int sys_munmap(void *ptr, size_t size)
+{
+     int sret;
+
+     errno = 0;
+     sret = syscall(__NR_munmap, ptr, size);
+     return sret;
+}
+
+static inline int sys_madvise(void *start, size_t len, int types)
+{
+     int sret;
+
+     errno = 0;
+     sret = syscall(__NR_madvise, start, len, types);
+     return sret;
+}
+
+static inline void *sys_mremap(void *addr, size_t old_len, size_t new_len,
+     unsigned long flags, void *new_addr)
+{
+     void *sret;
+
+     errno = 0;
+     sret = (void *) syscall(__NR_mremap, addr, old_len, new_len, flags, new_addr);
+     return sret;
+}

tools/testing/selftests/mm/memorysealing.h line 75

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.h new file +10 -0
+
+/*
+ * Parsing /proc/self/maps to get VMA's size and prot bit.
+ */
+static unsigned long get_vma_size(void *addr, int *prot)
+{
+     FILE *maps;
+     char line[256];
+     int size = 0;
+     uintptr_t  addr_start, addr_end;

Why not add a:

Quoted 4 lines
        uintptr_t addr_val = (uintptr_t)addr;

To avoid having to constantly cast below?

sure.

Quoted 8 lines

tools/testing/selftests/mm/memorysealing.h line 77

Quoted 2 lines
tools/testing/selftests/mm/memorysealing.h new file +2 -0
+     char protstr[5];
+     *prot = 0;

Nit but not sure there's much point in setting this to 0 even in failure cases?

With an error code return you can avoid having to do this.

[resp 8]
I don't think the error code return is worth the effort, it currently returns 0 size in case of error or not-found. For easy debug parsing errors, I can add logs. Notes, the parsing should always be successful.

Quoted 9 lines

tools/testing/selftests/mm/memorysealing.h line 81

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.h new file +4 -0
+
+     maps = fopen("/proc/self/maps", "r");
+     if (!maps)
+             return 0;

Might it be better to return an error code or something so we can identify this case? I guess any sensible call will fail on a 0 but you're sort of just implicitly hoping for this.

[resp 9] we could add logging in case of error.

Quoted 10 lines

tools/testing/selftests/mm/memorysealing.h line 85

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.h new file +4 -0
+
+     while (fgets(line, sizeof(line), maps)) {
+             if (sscanf(line, "%lx-%lx %4s", &addr_start, &addr_end, protstr) == 3) {
+                     if (addr_start == (uintptr_t) addr) {

This is a Yoda comparison again, let's put what we're comparing first, and the thing we're comparing to afterwards, e.g.

        if ((uintptr_t)addr == addr_start) ...

addr is the expected value from input and addr_start changes after parsing each line. The expected value (addr) is in second position, why is this yoda syntax ? IMO, introducing the yoda syntax concept for "==" is more confusing than useful, A==B is as clear as B==A.

Quoted 2 lines

Also I don't think a space after the (type) cast is necesary.

sure

Quoted 31 lines

tools/testing/selftests/mm/memorysealing.h line 96

Quoted 11 lines
tools/testing/selftests/mm/memorysealing.h new file +11 -0
+                             size = addr_end - addr_start;
+                             if (protstr[0] == 'r')
+                                     *prot |= PROT_READ;
+                             if (protstr[1] == 'w')
+                                     *prot |= PROT_WRITE;
+                             if (protstr[2] == 'x')
+                                     *prot |= PROT_EXEC;
+                             break;
+                     }
+             }
+     }

On the impl: This would be neater if you used guard clauses:

        while (fgets(line, sizeof(line), maps)) {
                if (sscanf(line, "%lx-%lx %4s", &addr_start, &addr_end, protstr) != 3)
                        continue;

                if (addr_val != addr_start)
                        continue;

                size = addr_end - addr_start;
                if (protstr[0] == 'r')
                        *prot |= PROT_READ;
                if (protstr[1] == 'w')
                        *prot |= PROT_WRITE;
                if (protstr[2] == 'x')
                        *prot |= PROT_EXEC;
                break;
        }
Quoted 2 lines

This is a lot more readable?

sure.

Quoted 8 lines

On doing this at all - it feels a bit crazy to check this, but I guess it might be the only way to assert things about merge/split.

I'm not sure it's _really useful_ to do that though - merges/splits are internal implementation details in effect (modulo mremap single VMA requirements), and mseal is an external interface, really the check should be around 'can forbidden operations be performed on sealed mappings'.

This is related to resp [5].
This test not only verifies the size, but also verifies the prot bits. The argument that VMA is an internal behavior is questionable, the /proc/pid/maps is user-facing and applications can read it and parse it.

Quoted 6 lines

However, if you do really want to do this, I think it would be much better to use the new ioctl interface for this [0] which should avoid having to do unpleasant text wrangling :)

[0]:https://lore.kernel.org/all/[email protected]/

I could try this. This is a new feature though, I do think this selftest should be self-standing and has as minimal dependency as possible. Is there harm of using /proc/pid/maps ? parsing /proc/pid/maps already used by selftest in lots of places (see below), I would prefer testing to use well-established patterns than relying on a newly developed feature.

Quoted 9 lines

filesystems/overlayfs/dev_in_maps.c
mm/mlock2-tests.c
mm/mremap_test.c
mm/virtual_address_range.c
mm/split_huge_page_test.c
filesystems/overlayfs/dev_in_maps.c
exec/load_address.c
bpf/trace_helpers.c

I have tried new ioctl PROCMAP_QUERY to replace get_vma_size, and observed a few facts:
1.The ioctl requires the caller to set the correct PROT bits for the query to succeed.
2. The ioctl returns the VMA containing the query address, which may not start at that address.
3. The ioctl doesn't return the sealing flag.

What get_vma_size wants is: for a given address, return the VMA started from that address, with PROT bits, size, and the sealing flag information.

In the next version, I'll add a check for the VMA's seal flag (by querying /proc/pid/smaps). Since the ioctl doesn't support returning the sealing flag and smaps already contain length/prot bit information, using an additional ioctl doesn't provide any benefit.

Thanks
-Jeff

Quoted 166 lines
Quoted 7 lines

tools/testing/selftests/mm/memorysealing.h line 98

Quoted 3 lines
tools/testing/selftests/mm/memorysealing.h new file +2 -0
+     fclose(maps);
+     return size;

If we don't find the line we don't seem to be indicating this, again worth being able to pass back an error?

It can be normal that we don't find a line, i.e. tests want to verify that a VMA does not exist at address, return 0 size is correct in this case. If a parsing error ever happened, the test would have failed at FIXTURE_SETUP to begin with.

Quoted 19 lines
Quoted 5 lines
tools/testing/selftests/mm/memorysealing.h new file +5 -0
+}
+
+static inline bool mseal_supported(void)
+{
+     int ret;

tools/testing/selftests/mm/memorysealing.h line 113

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.h new file +10 -0
+     void *ptr;
+     unsigned long page_size = getpagesize();
+
+     ptr = mmap(NULL, page_size, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+     if (ptr == MAP_FAILED)
+             return false;
+
+     ret = sys_mseal(ptr, page_size, 0);
+     if (ret < 0)
+             return false;

This is kind of cute, I mean it speaks to the need I think for us to be able to expose 'is X available?' programmatically. But I digress.

Quoted 2 lines

I guess this is ok, as this is something that should never fail.

You might recall that mseal is not available on the 32 bits kernel, automation might run the mseal_test on a 32 bit build. mseal_supported() detects this so tests can be skipped.

Quoted 3 lines

But we should definitely clean up after ourselves here whether this succeeds or fails.

please see resp [1].

Thanks!
-Jeff
[1] https://lore.kernel.org/all/CAKbZUD31EK2ah=vWJ46y4nL9OygzAa6ZxPnPHmWYO-sop5t+5Q@mail.gmail.com/
[2] https://lore.kernel.org/all/ko3pjllsgufbz33hqvwdpdsyxvgrgzqiodxexnpcng3mssffeh@dfgfkqlg46xa/
[3] https://lore.kernel.org/all/[email protected]/

Quoted 112 lines
Quoted 112 lines
tools/testing/selftests/mm/memorysealing.h new file +3 -0
+
+     return true;
+}
tools/testing/selftests/mm/mseal_test.c +1 -67
index ad17005521a8..8dd20341de3d 100644
@@ -517,30 +517,6 @@ static void test_seal_twice(void)
      REPORT_TEST_PASS();
 }
 
-static void test_seal_mprotect(bool seal)
-{
-     void *ptr;
-     unsigned long page_size = getpagesize();
-     unsigned long size = 4 * page_size;
-     int ret;
-
-     setup_single_address(size, &ptr);
-     FAIL_TEST_IF_FALSE(ptr != (void *)-1);
-
-     if (seal) {
-             ret = seal_single_address(ptr, size);
-             FAIL_TEST_IF_FALSE(!ret);
-     }
-
-     ret = sys_mprotect(ptr, size, PROT_READ | PROT_WRITE);
-     if (seal)
-             FAIL_TEST_IF_FALSE(ret < 0);
-     else
-             FAIL_TEST_IF_FALSE(!ret);
-
-     REPORT_TEST_PASS();
-}
-
 static void test_seal_start_mprotect(bool seal)
 {
      void *ptr;
@@ -658,41 +634,6 @@ static void test_seal_mprotect_unalign_len_variant_2(bool seal)
      REPORT_TEST_PASS();
 }
 
-static void test_seal_mprotect_two_vma(bool seal)
-{
-     void *ptr;
-     unsigned long page_size = getpagesize();
-     unsigned long size = 4 * page_size;
-     int ret;
-
-     setup_single_address(size, &ptr);
-     FAIL_TEST_IF_FALSE(ptr != (void *)-1);
-
-     /* use mprotect to split */
-     ret = sys_mprotect(ptr, page_size * 2, PROT_READ | PROT_WRITE);
-     FAIL_TEST_IF_FALSE(!ret);
-
-     if (seal) {
-             ret = seal_single_address(ptr, page_size * 4);
-             FAIL_TEST_IF_FALSE(!ret);
-     }
-
-     ret = sys_mprotect(ptr, page_size * 2, PROT_READ | PROT_WRITE);
-     if (seal)
-             FAIL_TEST_IF_FALSE(ret < 0);
-     else
-             FAIL_TEST_IF_FALSE(!ret);
-
-     ret = sys_mprotect(ptr + page_size * 2, page_size * 2,
-                     PROT_READ | PROT_WRITE);
-     if (seal)
-             FAIL_TEST_IF_FALSE(ret < 0);
-     else
-             FAIL_TEST_IF_FALSE(!ret);
-
-     REPORT_TEST_PASS();
-}
-
 static void test_seal_mprotect_two_vma_with_split(bool seal)
 {
      void *ptr;
@@ -1876,7 +1817,7 @@ int main(void)
      if (!pkey_supported())
              ksft_print_msg("PKEY not supported\n");
 
-     ksft_set_plan(88);
+     ksft_set_plan(84);
 
      test_seal_addseal();
      test_seal_unmapped_start();
@@ -1889,9 +1830,6 @@ int main(void)
      test_seal_zero_length();
      test_seal_twice();
 
-     test_seal_mprotect(false);
-     test_seal_mprotect(true);
-
      test_seal_start_mprotect(false);
      test_seal_start_mprotect(true);
 
@@ -1904,9 +1842,6 @@ int main(void)
      test_seal_mprotect_unalign_len_variant_2(false);
      test_seal_mprotect_unalign_len_variant_2(true);
 
-     test_seal_mprotect_two_vma(false);
-     test_seal_mprotect_two_vma(true);
-
      test_seal_mprotect_two_vma_with_split(false);
      test_seal_mprotect_two_vma_with_split(true);
 
--

2.47.1.613.gc27f4b7a9f-goog

#5 lore raw

Re: [RFC PATCH v1 1/1] selftest/mm: refactor mseal_test

Quoted 6 lines · Jeff Xu

Hi Lorenzo,

Gentle ping for my clarification questions.

I also tried the new ioctl PROCMAP_QUERY, please see below for details.

Hi Jeff,

Sorry I thought you'd send a new version which is why I didn't reply. I will take a look through and get back to you, it's on my whiteboard now...

Apologies for the delay, this was just an error!

And thanks for taking a look at the ioctl, will take a look and that when I get a sec also.

Cheers, Lorenzo

Quoted 952 lines · Jeff Xu
Quoted 756 lines

Hi Lorenzo,

Quoted 4 lines · Lorenzo Stoakes

Sorry for delay, was super busy leading up to xmas break, then had ~2.5 weeks off.

Thanks for reviewing. There are lots of comments, so it takes some time to go through comments and experiment with some of the suggested changes. Please see below.

Quoted 2 lines

And happy new year! :)

Happy new year !

Quoted 10 lines · On Wed, Dec 11, 2024 at 05:33:11AM +0000, [email protected] wrote:
Quoted 5 lines

From: Jeff Xu <[email protected]>

This change creates the initial version of memorysealing.c.

The introduction of memorysealing.c, which replaces mseal_test.c and

I mean I don't want to be a pain but I would kinda prefer to have 'mseal' everywhere mseal is to avoid confusion vs. memfd seals.

As I tried to explain, the memorysealing.c will eventually replace mseal_test.c, after all the tests are moved to use kselftest_karness. How about mseal_test_new.c ? I'm open to new names if you have one.

Quoted 11 lines

Of course we in the kernel absolutely _love_ to overload the meaning of terms but some traditions are worth breaking :)

Quoted 4 lines

uses the kselftest_harness, aims to initiate a discussion on using the selftest harness for memory sealing tests. Upon approval of this approach, the migration of tests from mseal_test.c to memorysealing.c can be implemented in a step-by-step manner.

Well, I for one like this approach so (unsurprisingly) :) but perhaps sensible to do it iteratively so we can also tweak things as we go.

Yes, that is the idea.

Quoted 85 lines
Quoted 7 lines

This tests addresses following feedback from previous reviews:

1> Use kselftest_harness instead of custom macro, such as EXPECT_XX, ASSERT_XX, etc. (Lorenzo Stoakes, Mark Brown) [1]

2> Use MAP_FAILED to check the return of mmap (Lorenzo Stoakes).

Thanks!

Quoted 75 lines

3> Adding a check for vma size and prot bits. The discussion for
this can be found in [2] [3], here is a brief summary:
This is to follow up on Pedro’s in-loop change (from can_modify_mm to can_modify_vma). When mseal_test is initially created, they have a common pattern: setup memory layout, seal the memory, perform a few mm-api steps, verify return code (not zero). Because of the nature of out-of-loop, it is sufficient to just verify the error code in a few cases.

With Pedro's in-loop change, the sealing check happens later in the stack, thus there are more things and scenarios to verify. And there was feedbacks to me that mseal_test should be extensive enough to discover all regressions. Hence I'm adding check for vma size and prot bits.

In this change: we created two fixtures:

Fixture basic: This creates a single VMA, the VMA has a
PROT_NONE page at each end to prevent auto-merging.

Fixture wo_vma: Two VMAs back to end, a PROT_NONE page at each end to prevent auto-merging.

In addition, I add one test (mprotec) in each fixture to demo the tests.

[1] https://lore.kernel.org/all/[email protected]/
[2] https://lore.kernel.org/all/CABi2SkUgDZtJtRJe+J9UNdtZn=EQzZcbMB685P=1rR7DUhg=6Q@mail.gmail.com/
[3] https://lore.kernel.org/all/2qywbjb5ebtgwkh354w3lj3vhaothvubjokxq5fhyri5jeeton@duqngzo3swjz/

---
 tools/testing/selftests/mm/.gitignore      |   1 +
 tools/testing/selftests/mm/Makefile        |   1 +
 tools/testing/selftests/mm/memorysealing.c | 182 +++++++++++++++++++++
 tools/testing/selftests/mm/memorysealing.h | 116 +++++++++++++
 tools/testing/selftests/mm/mseal_test.c    |  67 +-------
 5 files changed, 301 insertions(+), 66 deletions(-)
 create mode 100644 tools/testing/selftests/mm/memorysealing.c
 create mode 100644 tools/testing/selftests/mm/memorysealing.h
tools/testing/selftests/mm/.gitignore +1 -0
index a51a947b2d1d..982234a99f20 100644
@@ -57,3 +57,4 @@ hugetlb_dio
 pkey_sighandler_tests_32
 pkey_sighandler_tests_64
 guard-pages
+memorysealing
tools/testing/selftests/mm/Makefile +1 -0
index 93a46ac633df..08876624f46d 100644
@@ -67,6 +67,7 @@ TEST_GEN_FILES += map_populate
 ifneq (,$(filter $(ARCH),arm64 riscv riscv64 x86 x86_64))
 TEST_GEN_FILES += memfd_secret
 endif
+TEST_GEN_FILES += memorysealing
 TEST_GEN_FILES += migration
 TEST_GEN_FILES += mkdirty
 TEST_GEN_FILES += mlock-random-test
tools/testing/selftests/mm/memorysealing.c new file +7 -0
new file mode 100644
index 000000000000..e10032528b64
@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#define _GNU_SOURCE
+#include "../kselftest_harness.h"
+#include <asm-generic/unistd.h>
+#include <errno.h>
+#include <syscall.h>
+#include "memorysealing.h"
Quoted 9 lines

tools/testing/selftests/mm/memorysealing.c line 13

Quoted 6 lines
tools/testing/selftests/mm/memorysealing.c new file +6 -0
+
+/*
+ * To avoid auto-merging, create a VMA with PROT_NONE pages at each end.
+ * If unsuccessful, return MAP_FAILED.
+ */
+static void *setup_single_address(int size, int prot)

Nitty, but size should really be an unsigned long.

sure, thanks

Quoted 8 lines

tools/testing/selftests/mm/memorysealing.c line 17

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+{
+     int ret;
+     void *ptr;
+     unsigned long page_size = getpagesize();

Trivial, but we store page size in self->page_size so why not pass it as a parameter instead of looking up?

sure.

Quoted 21 lines
Quoted 8 lines
tools/testing/selftests/mm/memorysealing.c new file +8 -0
+
+     ptr = mmap(NULL, size + 2 * page_size, prot,
+             MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+
+     if (ptr == MAP_FAILED)
+             return MAP_FAILED;
+
+     /* To avoid auto-merging, change to PROT_NONE at each end. */

tools/testing/selftests/mm/memorysealing.c line 35

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.c new file +10 -0
+     ret = sys_mprotect(ptr, page_size, PROT_NONE);
+     if (ret != 0)
+             return MAP_FAILED;
+
+     ret = sys_mprotect(ptr + size + page_size, page_size, PROT_NONE);
+     if (ret != 0)
+             return MAP_FAILED;
+
+     return ptr + page_size;
+}

This could be done more easily with a single PROT_NONE, like:

Quoted 15 lines
        static void *setup_single_address(unsigned long size, int prot,
                        unsigned long page_size)
        {
                void *ptr;

                /* Ensure we only merge what we intend to. */
                ptr = mmap(NULL, size + 2 * page_size, PROT_NONE,
                           MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
                if (ptr == MAP_FAILED)
                        return MAP_FAILED;

                return mmap(&ptr[page_size], size, prot,
                            MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
        }

sure, create PROT_NONE mapping first, then use mprotect to change the middle part.

Quoted 7 lines

It's probably worth having an equivalent freeing function to avoid leaks:

        static int free_single_address(void *ptr, unsigned long size,
                        unsigned long page_size)
        {
                /* Also free the PROT_NONE sentinels. */
                return munmap(ptr - page_size, size + 2 * page_size);

[resp 1] could you clarify? I think we won't need freeing because mapping will be sealed. You might recall, mseal() blocks munmap(), and munmap() is atomic, so the above line that you suggested will result in no-action during FIXTURE_TEARDOWN. There will be separate test cases to test munmap under sealing. In addition, the virtual address space is big enough for this test complete without worry about the out-of-memory situation. Do I miss anything ?

Quoted 24 lines
        }
Quoted 22 lines
tools/testing/selftests/mm/memorysealing.c new file +22 -0
+
+FIXTURE(basic)
+{
+     unsigned long page_size;
+     unsigned long size;
+     void *ptr;
+};
+
+/*
+ * Setup for basic:
+ * Single VMA with 4 pages, prot = (PROT_READ | PROT_WRITE).
+ */
+FIXTURE_SETUP(basic)
+{
+     int prot;
+
+     self->page_size = getpagesize();
+
+     if (!mseal_supported())
+             SKIP(return, "mseal is not supported");
+
+     /* Create a single VMA with 4 pages, prot as PROT_READ | PROT_WRITE. */
Quoted 9 lines

tools/testing/selftests/mm/memorysealing.c line 62

Quoted 5 lines
tools/testing/selftests/mm/memorysealing.c new file +5 -0
+     self->size = self->page_size * 4;
+     self->ptr = setup_single_address(self->size, PROT_READ | PROT_WRITE);
+     EXPECT_NE(self->ptr, MAP_FAILED);
+
+     EXPECT_EQ(self->size, get_vma_size(self->ptr, &prot));

I mean fine but this check seems a bit overkill here, we don't need to check to ensure that PROT_NONE works.

[resp 2] Those checks are there, for the same reason that test cases usually check the return value of mmap(), mprotect() in the FIXTURE_SETUP. You are right that those calls are unlikely to fail, however, test cases generally do those "housekeeping tasks" to make sure everything is OK before the actual test. If you don't want to keep those, what is the downside of keeping them ?

Quoted 8 lines

tools/testing/selftests/mm/memorysealing.c line 63

Quoted 1 line
tools/testing/selftests/mm/memorysealing.c new file +1 -0
+     EXPECT_EQ(PROT_READ | PROT_WRITE, prot);

Nitty, but this seems a bit 'Yoda style', that is placing the expectation prior to the value whose expectation we are assessing, that is perhaps it'd be clearer as:

        EXPECT_EQ(prot, PROT_READ | PROT_WRITE);

[resp 3] Both styles are used in self tests and I believe it is equally clear, I can accommodate this request for this patch.

Quoted 3 lines

And again, I think this is really overkill here, if the kernel is unable to do an ordinary mapping correctly we have bigger problems than an mseal bug!

please see [resp 2]

Quoted 7 lines

tools/testing/selftests/mm/memorysealing.c line 67

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+};
+
+FIXTURE_TEARDOWN(basic)
+{

Probably worth adding munmap() teardown here.

please see [resp 1]

Quoted 44 lines
Quoted 33 lines
tools/testing/selftests/mm/memorysealing.c new file +33 -0
+}
+
+FIXTURE(two_vma)
+{
+     unsigned long page_size;
+     unsigned long size;
+     void *ptr;
+};
+
+/*
+ * Setup for two_vma:
+ * Two consecutive VMAs, each with 2 pages.
+ * The first VMA:  prot = PROT_READ.
+ * The second VMA: prot = (PROT_READ | PROT_WRITE).
+ */
+FIXTURE_SETUP(two_vma)
+{
+     int prot;
+     int ret;
+
+     self->page_size = getpagesize();
+
+     if (!mseal_supported())
+             SKIP(return, "mseal is not supported");
+
+     /* Create a single VMA with 4 pages, prot as PROT_READ | PROT_WRITE. */
+     self->size = getpagesize() * 4;
+     self->ptr = setup_single_address(self->size, PROT_READ | PROT_WRITE);
+     EXPECT_NE(self->ptr, MAP_FAILED);
+
+     /* Use mprotect to split as two VMA. */
+     ret = sys_mprotect(self->ptr, self->page_size * 2, PROT_READ);
+     ASSERT_EQ(ret, 0);

tools/testing/selftests/mm/memorysealing.c line 109

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.c new file +9 -0
+
 
+     /* Verify the first VMA is 2 pages and prot bits */
+     EXPECT_EQ(self->page_size * 2, get_vma_size(self->ptr, &prot));
+     EXPECT_EQ(PROT_READ, prot);
+
+     /* Verify the second VMA is 2 pages and prot bits */
+     EXPECT_EQ(self->page_size * 2,
+             get_vma_size(self->ptr + self->page_size * 2, &prot));
+     EXPECT_EQ(PROT_READ | PROT_WRITE, prot);
Quoted 2 lines

Again, as with the prior fixture, it seems a bit overkill, as this is essentially testing 'does mmap() and mprotect()' work. We should hope so :)

Please see [resp 2]

Quoted 7 lines

tools/testing/selftests/mm/memorysealing.c line 113

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+};
+
+FIXTURE_TEARDOWN(two_vma)
+{

Same comment as for the basic fixture - let's clean up after ourselves.

please see [resp 1]

Quoted 22 lines
Quoted 8 lines
tools/testing/selftests/mm/memorysealing.c new file +8 -0
+}
+
+/*
+ * Verify mprotect is blocked.
+ */
+TEST_F(basic, mprotect_basic)
+{
+     int ret;

tools/testing/selftests/mm/memorysealing.c line 131

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.c new file +10 -0
+     unsigned long size;
+     int prot;
+
+     /* Seal the mapping. */
+     ret = sys_mseal(self->ptr, self->size, 0);
+     ASSERT_EQ(ret, 0);
+
+     /* Verify mprotect is blocked. */
+     ret = sys_mprotect(self->ptr, self->size, PROT_READ);
+     EXPECT_GT(0, ret);

Yeah this one is kinda egregious, this is genuinely hard to read. Wouldn't this be better as:

Quoted 7 lines
        EXPECT_NE(ret, 0);

As it explicitly says 'not equal to a success case'. Rather than 'wait 0 is _greater than_ the result which means the result is _less than_ 0 which means an error but let me check the man page can it be positive, oh ok it's -1 on error, 0 on success', which was the Lorenzo thought process... :)

[resp 4] The man page says: "On success, mprotect() and pkey_mprotect() return zero. On error, these system calls return -1, and errno is set to indicate the error."

I wll switch EXPECT_EQ(ret, -1) which is precisely what the man page says.

Quoted 7 lines
Quoted 1 line

+ EXPECT_EQ(EPERM, errno);

Let's invert these, Yoda style isn't really useful here and is a little harder to read, e.g. we should do:

        EXPECT_EQ(errno, EPERM);

please see [resp 3]

Quoted 8 lines

tools/testing/selftests/mm/memorysealing.c line 137

Quoted 5 lines
tools/testing/selftests/mm/memorysealing.c new file +5 -0
+
+     /* Verify the VMA (sealed) isn't changed */
+     size = get_vma_size(self->ptr, &prot);
+     EXPECT_EQ(self->size, size);
+     EXPECT_EQ(PROT_READ | PROT_WRITE, prot);

Again, no to Yoda :)

please see [resp 3]

Quoted 3 lines

I also wonder how useful this is - I guess belts + braces, and linux _can_ do partial failures, but is that something we would care about in practice?

[resp 5]
Those checks will help to detect regression, such as when Pedro Falcato implemented in-loop change [1]. Liam R. Howlett also commented that mseal_test should be extensive enough to check for size and prot to avoid future regression [2]

For your question about partial failure, there will be additional tests for partial-sealed-address range, and those will check the sealed mapping only.

Quoted 11 lines

tools/testing/selftests/mm/memorysealing.c line 144

Quoted 7 lines
tools/testing/selftests/mm/memorysealing.c new file +7 -0
+}
+
+/*
+ * Seal both VMAs in one mseal call.
+ * Verify mprotect is blocked on both VMAs in various cases.
+ */
+TEST_F(two_vma, mprotect)

I'm guessing you aren't necessarily covering _all_ mprotect cases here (though perhaps you intend to later, iteratively?)

Yes.

Quoted 8 lines

tools/testing/selftests/mm/memorysealing.c line 73

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+{
+     int ret;
+     int prot;
+     unsigned long size;

I think 'size' is a bit confusing as it refers to the size ascertained from the get_vma_size() later on. Perhaps call it actual_size?

To help readability, I will change size to vma_size, which corresponds to the return of get_vma_size().

Quoted 10 lines

Maybe worth adding:

        void *ptr = self->ptr;
        unsigned long size = self->size;
        unsigned long page_size = self->page_size;

For convenience?

This is totally optional though, maybe more effort than it's worth.

I don't think it is worth it.

Quoted 5 lines
Quoted 5 lines
tools/testing/selftests/mm/memorysealing.c new file +5 -0
+
+     /* Seal both VMAs in one mseal call. */
+     ret = sys_mseal(self->ptr, self->size, 0);
+     ASSERT_EQ(ret, 0);
+
Quoted 9 lines

tools/testing/selftests/mm/memorysealing.c line 156

Quoted 3 lines
tools/testing/selftests/mm/memorysealing.c new file +3 -0
+     /* Verify mprotect is rejected on the first VMA. */
+     ret = sys_mprotect(self->ptr, self->page_size * 2,
+             PROT_READ | PROT_EXEC);

Why PROT_READ | PROT_EXEC? Is this arbitrary? To be thorough shouldn't you loop through all of the prot flags that you think should fail? And perhaps check what happens if you mprotect() the VMA to set it to what it already is?

[resp 6]
Not arbitrary. As commented in FIXTURE_SETUP, the first VMA is
PROT_READ, and the second VMA is PROT_READ | PROT_WRITE. The test
wants to use mprotect to change the proc bit to a different set.

For your question about mprotect() the sealed vma to what it already is (doesn't change any attribute), I don't want to solidify the current behavior (which is to block). It should be successful instead. With in-loop check and partial update behavior, there is no reason to block it, i.e. no security benefit. I already plan to address this.

Quoted 4 lines
Quoted 1 line

+ EXPECT_GT(0, ret);

Please convert to EXPECT_NE(ret, 0)

please see [resp 4]

Quoted 4 lines
Quoted 1 line

+ EXPECT_EQ(EPERM, errno);

Please invert to EXPECT_EQ(errno, EPERM)

please see [resp 3]

Quoted 10 lines

tools/testing/selftests/mm/memorysealing.c line 162

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+
+     /* Verify mprotect is rejected on the second VMA. */
+     ret = sys_mprotect(self->ptr, self->page_size * 2,
+             PROT_READ | PROT_EXEC);

Hang on, isn't this just a repeat of the first test? Shouldn't this be:

        ret = sys_mprotect(&self->ptr[self->page_size * 2],
                self->page_size * 2, PROT_READ | PROT_EXEC);

[resp 7] Not the same, this test has two VMA, and the mseal() covers both VMAs in one call. In the first test, i.e. basic, mprotect_basic, mseal is called on single VMA.

Quoted 5 lines

tools/testing/selftests/mm/memorysealing.c

Quoted 2 lines
tools/testing/selftests/mm/memorysealing.c new file +2 -0
+     EXPECT_GT(0, ret);
+     EXPECT_EQ(EPERM, errno);

Same comment as above re: ordering.

please see [resp 3]

Quoted 7 lines

tools/testing/selftests/mm/memorysealing.c line 168

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+
+     /* Attempt of mprotect two VMAs at the same call is blocked */
+     ret = sys_mprotect(self->ptr, self->size,
+             PROT_READ | PROT_EXEC);

Same comment about iterating through prot flags that should fail as above.

please see [resp 7]

Quoted 5 lines

tools/testing/selftests/mm/memorysealing.c

Quoted 2 lines
tools/testing/selftests/mm/memorysealing.c new file +2 -0
+     EXPECT_GT(0, ret);
+     EXPECT_EQ(EPERM, errno);

Same comment as above re: ordering.

please see [resp 3]

Quoted 8 lines

tools/testing/selftests/mm/memorysealing.c line 175

Quoted 5 lines
tools/testing/selftests/mm/memorysealing.c new file +5 -0
+
+     /* Verify both VMAs aren't changed. */
+     size = get_vma_size(self->ptr, &prot);
+     EXPECT_EQ(self->page_size * 2, size);
+     EXPECT_EQ(PROT_READ, prot);

Same comment as above re: ordering.

please see [resp 3]

Quoted 7 lines

tools/testing/selftests/mm/memorysealing.c line 179

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.c new file +4 -0
+
+     size = get_vma_size(self->ptr + self->page_size * 2, &prot);
+     EXPECT_EQ(self->page_size * 2, size);
+     EXPECT_EQ(PROT_READ | PROT_WRITE, prot);

Same comment as above re: ordering.

please see [resp 3]

Quoted 11 lines
Quoted 11 lines
tools/testing/selftests/mm/memorysealing.c new file +3 -0
+}
+
+TEST_HARNESS_MAIN
tools/testing/selftests/mm/memorysealing.h new file +2 -0
new file mode 100644
index 000000000000..aee6e6700028
@@ -0,0 +1,116 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#include <syscall.h>
Quoted 9 lines

tools/testing/selftests/mm/memorysealing.h line 7

Quoted 5 lines
tools/testing/selftests/mm/memorysealing.h new file +5 -0
+
+/*
+ * Define sys_xyx to call syscall directly.
+ * This is needed because we want to avoid calling glibc and
+ * test syscall directly.

I do wonder if this is worth it, but I mean, I guess it's not too egregious if it's wrapped like this. Same comment for other wrappers.

The self-test should directly test the kernel syscall without any intermediate layer. selftest is not a libc test. It is practical too, glibc's behavior can change across versions which result inconsistent, and Padro Falcato reported one of this and fixed in [3]

Quoted 11 lines

tools/testing/selftests/mm/memorysealing.h line 15

Quoted 8 lines
tools/testing/selftests/mm/memorysealing.h new file +8 -0
+ * The only exception is mmap, which _NR_mmap2 is not defined for
+ * some ARM architecture.
+ */
+static inline int sys_mseal(void *start, size_t len, unsigned long flags)
+{
+     int sret;
+
+     errno = 0;

Why are we setting this to 0? Same comment for all sys_XXX() wrappers.

The test is only interested in the latest error associated with the failed syscall, and I'm not sure the kernel clears the errno for each system call. Note, there is no glibc layer here.

Quoted 10 lines

tools/testing/selftests/mm/memorysealing.h line 17

Quoted 2 lines
tools/testing/selftests/mm/memorysealing.h new file +2 -0
+     sret = syscall(__NR_mseal, start, len, flags);
+     return sret;

Nit, but this seems a bit redundant, why not just drop the sret assignment, and simply:

        return syscall(__NR_mseal, start, len, flags);

Same comment for all sys_XXX() wrappers.

[resp 6] I think this is a different taste in coding style. For the test, I prefer to have local variables so it is easy to show them in the debugger, when needed.

Quoted 6 lines
Quoted 6 lines
tools/testing/selftests/mm/memorysealing.h new file +6 -0
+}
+
+static inline int sys_mprotect(void *ptr, size_t size, unsigned long prot)
+{
+     int sret;
+
Quoted 9 lines

tools/testing/selftests/mm/memorysealing.h line 28

Quoted 5 lines
tools/testing/selftests/mm/memorysealing.h new file +5 -0
+     errno = 0;
+     sret = syscall(__NR_mprotect, ptr, size, prot);
+     return sret;
+}
+

The wrappers below don't seem to be used yet, could we delay putting them in until they are actually used?

Sure, I will remove sys_mprotect_pkey for this patch.

Quoted 50 lines
Quoted 37 lines
tools/testing/selftests/mm/memorysealing.h new file +37 -0
+static inline int sys_mprotect_pkey(void *ptr, size_t size,
+     unsigned long orig_prot, unsigned long pkey)
+{
+     int sret;
+
+     errno = 0;
+     sret = syscall(__NR_pkey_mprotect, ptr, size, orig_prot, pkey);
+     return sret;
+}
+
+static inline int sys_munmap(void *ptr, size_t size)
+{
+     int sret;
+
+     errno = 0;
+     sret = syscall(__NR_munmap, ptr, size);
+     return sret;
+}
+
+static inline int sys_madvise(void *start, size_t len, int types)
+{
+     int sret;
+
+     errno = 0;
+     sret = syscall(__NR_madvise, start, len, types);
+     return sret;
+}
+
+static inline void *sys_mremap(void *addr, size_t old_len, size_t new_len,
+     unsigned long flags, void *new_addr)
+{
+     void *sret;
+
+     errno = 0;
+     sret = (void *) syscall(__NR_mremap, addr, old_len, new_len, flags, new_addr);
+     return sret;
+}

tools/testing/selftests/mm/memorysealing.h line 75

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.h new file +10 -0
+
+/*
+ * Parsing /proc/self/maps to get VMA's size and prot bit.
+ */
+static unsigned long get_vma_size(void *addr, int *prot)
+{
+     FILE *maps;
+     char line[256];
+     int size = 0;
+     uintptr_t  addr_start, addr_end;

Why not add a:

Quoted 4 lines
        uintptr_t addr_val = (uintptr_t)addr;

To avoid having to constantly cast below?

sure.

Quoted 8 lines

tools/testing/selftests/mm/memorysealing.h line 77

Quoted 2 lines
tools/testing/selftests/mm/memorysealing.h new file +2 -0
+     char protstr[5];
+     *prot = 0;

Nit but not sure there's much point in setting this to 0 even in failure cases?

With an error code return you can avoid having to do this.

[resp 8]
I don't think the error code return is worth the effort, it currently returns 0 size in case of error or not-found. For easy debug parsing errors, I can add logs. Notes, the parsing should always be successful.

Quoted 9 lines

tools/testing/selftests/mm/memorysealing.h line 81

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.h new file +4 -0
+
+     maps = fopen("/proc/self/maps", "r");
+     if (!maps)
+             return 0;

Might it be better to return an error code or something so we can identify this case? I guess any sensible call will fail on a 0 but you're sort of just implicitly hoping for this.

[resp 9] we could add logging in case of error.

Quoted 10 lines

tools/testing/selftests/mm/memorysealing.h line 85

Quoted 4 lines
tools/testing/selftests/mm/memorysealing.h new file +4 -0
+
+     while (fgets(line, sizeof(line), maps)) {
+             if (sscanf(line, "%lx-%lx %4s", &addr_start, &addr_end, protstr) == 3) {
+                     if (addr_start == (uintptr_t) addr) {

This is a Yoda comparison again, let's put what we're comparing first, and the thing we're comparing to afterwards, e.g.

        if ((uintptr_t)addr == addr_start) ...

addr is the expected value from input and addr_start changes after parsing each line. The expected value (addr) is in second position, why is this yoda syntax ? IMO, introducing the yoda syntax concept for "==" is more confusing than useful, A==B is as clear as B==A.

Quoted 2 lines

Also I don't think a space after the (type) cast is necesary.

sure

Quoted 31 lines

tools/testing/selftests/mm/memorysealing.h line 96

Quoted 11 lines
tools/testing/selftests/mm/memorysealing.h new file +11 -0
+                             size = addr_end - addr_start;
+                             if (protstr[0] == 'r')
+                                     *prot |= PROT_READ;
+                             if (protstr[1] == 'w')
+                                     *prot |= PROT_WRITE;
+                             if (protstr[2] == 'x')
+                                     *prot |= PROT_EXEC;
+                             break;
+                     }
+             }
+     }

On the impl: This would be neater if you used guard clauses:

        while (fgets(line, sizeof(line), maps)) {
                if (sscanf(line, "%lx-%lx %4s", &addr_start, &addr_end, protstr) != 3)
                        continue;

                if (addr_val != addr_start)
                        continue;

                size = addr_end - addr_start;
                if (protstr[0] == 'r')
                        *prot |= PROT_READ;
                if (protstr[1] == 'w')
                        *prot |= PROT_WRITE;
                if (protstr[2] == 'x')
                        *prot |= PROT_EXEC;
                break;
        }
Quoted 2 lines

This is a lot more readable?

sure.

Quoted 8 lines

On doing this at all - it feels a bit crazy to check this, but I guess it might be the only way to assert things about merge/split.

I'm not sure it's _really useful_ to do that though - merges/splits are internal implementation details in effect (modulo mremap single VMA requirements), and mseal is an external interface, really the check should be around 'can forbidden operations be performed on sealed mappings'.

This is related to resp [5].
This test not only verifies the size, but also verifies the prot bits. The argument that VMA is an internal behavior is questionable, the /proc/pid/maps is user-facing and applications can read it and parse it.

Quoted 6 lines

However, if you do really want to do this, I think it would be much better to use the new ioctl interface for this [0] which should avoid having to do unpleasant text wrangling :)

[0]:https://lore.kernel.org/all/[email protected]/

I could try this. This is a new feature though, I do think this selftest should be self-standing and has as minimal dependency as possible. Is there harm of using /proc/pid/maps ? parsing /proc/pid/maps already used by selftest in lots of places (see below), I would prefer testing to use well-established patterns than relying on a newly developed feature.

Quoted 9 lines

filesystems/overlayfs/dev_in_maps.c
mm/mlock2-tests.c
mm/mremap_test.c
mm/virtual_address_range.c
mm/split_huge_page_test.c
filesystems/overlayfs/dev_in_maps.c
exec/load_address.c
bpf/trace_helpers.c

I have tried new ioctl PROCMAP_QUERY to replace get_vma_size, and observed a few facts:
1.The ioctl requires the caller to set the correct PROT bits for the query to succeed.
2. The ioctl returns the VMA containing the query address, which may not start at that address.
3. The ioctl doesn't return the sealing flag.

What get_vma_size wants is: for a given address, return the VMA started from that address, with PROT bits, size, and the sealing flag information.

In the next version, I'll add a check for the VMA's seal flag (by querying /proc/pid/smaps). Since the ioctl doesn't support returning the sealing flag and smaps already contain length/prot bit information, using an additional ioctl doesn't provide any benefit.

Thanks
-Jeff

Quoted 166 lines
Quoted 7 lines

tools/testing/selftests/mm/memorysealing.h line 98

Quoted 3 lines
tools/testing/selftests/mm/memorysealing.h new file +2 -0
+     fclose(maps);
+     return size;

If we don't find the line we don't seem to be indicating this, again worth being able to pass back an error?

It can be normal that we don't find a line, i.e. tests want to verify that a VMA does not exist at address, return 0 size is correct in this case. If a parsing error ever happened, the test would have failed at FIXTURE_SETUP to begin with.

Quoted 19 lines
Quoted 5 lines
tools/testing/selftests/mm/memorysealing.h new file +5 -0
+}
+
+static inline bool mseal_supported(void)
+{
+     int ret;

tools/testing/selftests/mm/memorysealing.h line 113

Quoted 10 lines
tools/testing/selftests/mm/memorysealing.h new file +10 -0
+     void *ptr;
+     unsigned long page_size = getpagesize();
+
+     ptr = mmap(NULL, page_size, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+     if (ptr == MAP_FAILED)
+             return false;
+
+     ret = sys_mseal(ptr, page_size, 0);
+     if (ret < 0)
+             return false;

This is kind of cute, I mean it speaks to the need I think for us to be able to expose 'is X available?' programmatically. But I digress.

Quoted 2 lines

I guess this is ok, as this is something that should never fail.

You might recall that mseal is not available on the 32 bits kernel, automation might run the mseal_test on a 32 bit build. mseal_supported() detects this so tests can be skipped.

Quoted 3 lines

But we should definitely clean up after ourselves here whether this succeeds or fails.

please see resp [1].

Thanks!
-Jeff
[1] https://lore.kernel.org/all/CAKbZUD31EK2ah=vWJ46y4nL9OygzAa6ZxPnPHmWYO-sop5t+5Q@mail.gmail.com/
[2] https://lore.kernel.org/all/ko3pjllsgufbz33hqvwdpdsyxvgrgzqiodxexnpcng3mssffeh@dfgfkqlg46xa/
[3] https://lore.kernel.org/all/[email protected]/

Quoted 112 lines
Quoted 112 lines
tools/testing/selftests/mm/memorysealing.h new file +3 -0
+
+     return true;
+}
tools/testing/selftests/mm/mseal_test.c +1 -67
index ad17005521a8..8dd20341de3d 100644
@@ -517,30 +517,6 @@ static void test_seal_twice(void)
      REPORT_TEST_PASS();
 }
 
-static void test_seal_mprotect(bool seal)
-{
-     void *ptr;
-     unsigned long page_size = getpagesize();
-     unsigned long size = 4 * page_size;
-     int ret;
-
-     setup_single_address(size, &ptr);
-     FAIL_TEST_IF_FALSE(ptr != (void *)-1);
-
-     if (seal) {
-             ret = seal_single_address(ptr, size);
-             FAIL_TEST_IF_FALSE(!ret);
-     }
-
-     ret = sys_mprotect(ptr, size, PROT_READ | PROT_WRITE);
-     if (seal)
-             FAIL_TEST_IF_FALSE(ret < 0);
-     else
-             FAIL_TEST_IF_FALSE(!ret);
-
-     REPORT_TEST_PASS();
-}
-
 static void test_seal_start_mprotect(bool seal)
 {
      void *ptr;
@@ -658,41 +634,6 @@ static void test_seal_mprotect_unalign_len_variant_2(bool seal)
      REPORT_TEST_PASS();
 }
 
-static void test_seal_mprotect_two_vma(bool seal)
-{
-     void *ptr;
-     unsigned long page_size = getpagesize();
-     unsigned long size = 4 * page_size;
-     int ret;
-
-     setup_single_address(size, &ptr);
-     FAIL_TEST_IF_FALSE(ptr != (void *)-1);
-
-     /* use mprotect to split */
-     ret = sys_mprotect(ptr, page_size * 2, PROT_READ | PROT_WRITE);
-     FAIL_TEST_IF_FALSE(!ret);
-
-     if (seal) {
-             ret = seal_single_address(ptr, page_size * 4);
-             FAIL_TEST_IF_FALSE(!ret);
-     }
-
-     ret = sys_mprotect(ptr, page_size * 2, PROT_READ | PROT_WRITE);
-     if (seal)
-             FAIL_TEST_IF_FALSE(ret < 0);
-     else
-             FAIL_TEST_IF_FALSE(!ret);
-
-     ret = sys_mprotect(ptr + page_size * 2, page_size * 2,
-                     PROT_READ | PROT_WRITE);
-     if (seal)
-             FAIL_TEST_IF_FALSE(ret < 0);
-     else
-             FAIL_TEST_IF_FALSE(!ret);
-
-     REPORT_TEST_PASS();
-}
-
 static void test_seal_mprotect_two_vma_with_split(bool seal)
 {
      void *ptr;
@@ -1876,7 +1817,7 @@ int main(void)
      if (!pkey_supported())
              ksft_print_msg("PKEY not supported\n");
 
-     ksft_set_plan(88);
+     ksft_set_plan(84);
 
      test_seal_addseal();
      test_seal_unmapped_start();
@@ -1889,9 +1830,6 @@ int main(void)
      test_seal_zero_length();
      test_seal_twice();
 
-     test_seal_mprotect(false);
-     test_seal_mprotect(true);
-
      test_seal_start_mprotect(false);
      test_seal_start_mprotect(true);
 
@@ -1904,9 +1842,6 @@ int main(void)
      test_seal_mprotect_unalign_len_variant_2(false);
      test_seal_mprotect_unalign_len_variant_2(true);
 
-     test_seal_mprotect_two_vma(false);
-     test_seal_mprotect_two_vma(true);
-
      test_seal_mprotect_two_vma_with_split(false);
      test_seal_mprotect_two_vma_with_split(true);
 
--

2.47.1.613.gc27f4b7a9f-goog