tools/testing/selftests: add forked (un)/faulted VMA merge tests

Now we correctly handle forked faulted/unfaulted merge on mremap(),
exhaustively assert that we handle this correctly.

Do this in the less duplicative way by adding a new merge_with_fork
fixture and forked/unforked variants, and abstract the forking logic as
necessary to avoid code duplication with this also.

Link: https://lkml.kernel.org/r/1daf76d89fdb9d96f38a6a0152d8f3c2e9e30ac7.1767638272.git.lorenzo.stoakes@oracle.com
Fixes: 879bca0a2c4f ("mm/vma: fix incorrectly disallowed anonymous VMA merges")
Signed-off-by: Lorenzo Stoakes <lorenzo.stoakes@oracle.com>
Cc: David Hildenbrand (Red Hat) <david@kernel.org>
Cc: Jann Horn <jannh@google.com>
Cc: Jeongjun Park <aha310510@gmail.com>
Cc: Liam Howlett <liam.howlett@oracle.com>
Cc: Pedro Falcato <pfalcato@suse.de>
Cc: Rik van Riel <riel@surriel.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Yeoreum Yun <yeoreum.yun@arm.com>
Cc: Harry Yoo <harry.yoo@oracle.com>
Cc: <stable@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/tools/testing/selftests/mm/merge.c b/tools/testing/selftests/mm/merge.c
index 22be149f71093f5060ad1bd87dfa160b26942c88..10b686102b79d90c1efbb13e8cba2fee52bd5f97 100644 (file)
--- a/tools/testing/selftests/mm/merge.c
+++ b/tools/testing/selftests/mm/merge.c
@@ -22,12 +22,37 @@ FIXTURE(merge)
        struct procmap_fd procmap;
 };
 
+static char *map_carveout(unsigned int page_size)
+{
+       return mmap(NULL, 30 * page_size, PROT_NONE,
+                   MAP_ANON | MAP_PRIVATE, -1, 0);
+}
+
+static pid_t do_fork(struct procmap_fd *procmap)
+{
+       pid_t pid = fork();
+
+       if (pid == -1)
+               return -1;
+       if (pid != 0) {
+               wait(NULL);
+               return pid;
+       }
+
+       /* Reopen for child. */
+       if (close_procmap(procmap))
+               return -1;
+       if (open_self_procmap(procmap))
+               return -1;
+
+       return 0;
+}
+
 FIXTURE_SETUP(merge)
 {
        self->page_size = psize();
        /* Carve out PROT_NONE region to map over. */
-       self->carveout = mmap(NULL, 30 * self->page_size, PROT_NONE,
-                             MAP_ANON | MAP_PRIVATE, -1, 0);
+       self->carveout = map_carveout(self->page_size);
        ASSERT_NE(self->carveout, MAP_FAILED);
        /* Setup PROCMAP_QUERY interface. */
        ASSERT_EQ(open_self_procmap(&self->procmap), 0);
@@ -36,7 +61,8 @@ FIXTURE_SETUP(merge)
 FIXTURE_TEARDOWN(merge)
 {
        ASSERT_EQ(munmap(self->carveout, 30 * self->page_size), 0);
-       ASSERT_EQ(close_procmap(&self->procmap), 0);
+       /* May fail for parent of forked process. */
+       close_procmap(&self->procmap);
        /*
         * Clear unconditionally, as some tests set this. It is no issue if this
         * fails (KSM may be disabled for instance).
@@ -44,6 +70,44 @@ FIXTURE_TEARDOWN(merge)
        prctl(PR_SET_MEMORY_MERGE, 0, 0, 0, 0);
 }
 
+FIXTURE(merge_with_fork)
+{
+       unsigned int page_size;
+       char *carveout;
+       struct procmap_fd procmap;
+};
+
+FIXTURE_VARIANT(merge_with_fork)
+{
+       bool forked;
+};
+
+FIXTURE_VARIANT_ADD(merge_with_fork, forked)
+{
+       .forked = true,
+};
+
+FIXTURE_VARIANT_ADD(merge_with_fork, unforked)
+{
+       .forked = false,
+};
+
+FIXTURE_SETUP(merge_with_fork)
+{
+       self->page_size = psize();
+       self->carveout = map_carveout(self->page_size);
+       ASSERT_NE(self->carveout, MAP_FAILED);
+       ASSERT_EQ(open_self_procmap(&self->procmap), 0);
+}
+
+FIXTURE_TEARDOWN(merge_with_fork)
+{
+       ASSERT_EQ(munmap(self->carveout, 30 * self->page_size), 0);
+       ASSERT_EQ(close_procmap(&self->procmap), 0);
+       /* See above. */
+       prctl(PR_SET_MEMORY_MERGE, 0, 0, 0, 0);
+}
+
 TEST_F(merge, mprotect_unfaulted_left)
 {
        unsigned int page_size = self->page_size;
@@ -322,8 +386,8 @@ TEST_F(merge, forked_target_vma)
        unsigned int page_size = self->page_size;
        char *carveout = self->carveout;
        struct procmap_fd *procmap = &self->procmap;
-       pid_t pid;
        char *ptr, *ptr2;
+       pid_t pid;
        int i;
 
        /*
@@ -344,19 +408,10 @@ TEST_F(merge, forked_target_vma)
         */
        ptr[0] = 'x';
 
-       pid = fork();
+       pid = do_fork(&self->procmap);
        ASSERT_NE(pid, -1);
-
-       if (pid != 0) {
-               wait(NULL);
+       if (pid != 0)
                return;
-       }
-
-       /* Child process below: */
-
-       /* Reopen for child. */
-       ASSERT_EQ(close_procmap(&self->procmap), 0);
-       ASSERT_EQ(open_self_procmap(&self->procmap), 0);
 
        /* unCOWing everything does not cause the AVC to go away. */
        for (i = 0; i < 5 * page_size; i += page_size)
@@ -386,8 +441,8 @@ TEST_F(merge, forked_source_vma)
        unsigned int page_size = self->page_size;
        char *carveout = self->carveout;
        struct procmap_fd *procmap = &self->procmap;
-       pid_t pid;
        char *ptr, *ptr2;
+       pid_t pid;
        int i;
 
        /*
@@ -408,19 +463,10 @@ TEST_F(merge, forked_source_vma)
         */
        ptr[0] = 'x';
 
-       pid = fork();
+       pid = do_fork(&self->procmap);
        ASSERT_NE(pid, -1);
-
-       if (pid != 0) {
-               wait(NULL);
+       if (pid != 0)
                return;
-       }
-
-       /* Child process below: */
-
-       /* Reopen for child. */
-       ASSERT_EQ(close_procmap(&self->procmap), 0);
-       ASSERT_EQ(open_self_procmap(&self->procmap), 0);
 
        /* unCOWing everything does not cause the AVC to go away. */
        for (i = 0; i < 5 * page_size; i += page_size)
@@ -1171,10 +1217,11 @@ TEST_F(merge, mremap_correct_placed_faulted)
        ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 15 * page_size);
 }
 
-TEST_F(merge, mremap_faulted_to_unfaulted_prev)
+TEST_F(merge_with_fork, mremap_faulted_to_unfaulted_prev)
 {
        struct procmap_fd *procmap = &self->procmap;
        unsigned int page_size = self->page_size;
+       unsigned long offset;
        char *ptr_a, *ptr_b;
 
        /*
@@ -1197,6 +1244,14 @@ TEST_F(merge, mremap_faulted_to_unfaulted_prev)
        /* Fault it in. */
        ptr_a[0] = 'x';
 
+       if (variant->forked) {
+               pid_t pid = do_fork(&self->procmap);
+
+               ASSERT_NE(pid, -1);
+               if (pid != 0)
+                       return;
+       }
+
        /*
         * Now move it out of the way so we can place VMA B in position,
         * unfaulted.
@@ -1220,16 +1275,19 @@ TEST_F(merge, mremap_faulted_to_unfaulted_prev)
                       &self->carveout[page_size + 3 * page_size]);
        ASSERT_NE(ptr_a, MAP_FAILED);
 
-       /* The VMAs should have merged. */
+       /* The VMAs should have merged, if not forked. */
        ASSERT_TRUE(find_vma_procmap(procmap, ptr_b));
        ASSERT_EQ(procmap->query.vma_start, (unsigned long)ptr_b);
-       ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr_b + 6 * page_size);
+
+       offset = variant->forked ? 3 * page_size : 6 * page_size;
+       ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr_b + offset);
 }
 
-TEST_F(merge, mremap_faulted_to_unfaulted_next)
+TEST_F(merge_with_fork, mremap_faulted_to_unfaulted_next)
 {
        struct procmap_fd *procmap = &self->procmap;
        unsigned int page_size = self->page_size;
+       unsigned long offset;
        char *ptr_a, *ptr_b;
 
        /*
@@ -1253,6 +1311,14 @@ TEST_F(merge, mremap_faulted_to_unfaulted_next)
        /* Fault it in. */
        ptr_a[0] = 'x';
 
+       if (variant->forked) {
+               pid_t pid = do_fork(&self->procmap);
+
+               ASSERT_NE(pid, -1);
+               if (pid != 0)
+                       return;
+       }
+
        /*
         * Now move it out of the way so we can place VMA B in position,
         * unfaulted.
@@ -1276,16 +1342,18 @@ TEST_F(merge, mremap_faulted_to_unfaulted_next)
                       &self->carveout[page_size]);
        ASSERT_NE(ptr_a, MAP_FAILED);
 
-       /* The VMAs should have merged. */
+       /* The VMAs should have merged, if not forked. */
        ASSERT_TRUE(find_vma_procmap(procmap, ptr_a));
        ASSERT_EQ(procmap->query.vma_start, (unsigned long)ptr_a);
-       ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr_a + 6 * page_size);
+       offset = variant->forked ? 3 * page_size : 6 * page_size;
+       ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr_a + offset);
 }
 
-TEST_F(merge, mremap_faulted_to_unfaulted_prev_unfaulted_next)
+TEST_F(merge_with_fork, mremap_faulted_to_unfaulted_prev_unfaulted_next)
 {
        struct procmap_fd *procmap = &self->procmap;
        unsigned int page_size = self->page_size;
+       unsigned long offset;
        char *ptr_a, *ptr_b, *ptr_c;
 
        /*
@@ -1307,6 +1375,14 @@ TEST_F(merge, mremap_faulted_to_unfaulted_prev_unfaulted_next)
        /* Fault it in. */
        ptr_b[0] = 'x';
 
+       if (variant->forked) {
+               pid_t pid = do_fork(&self->procmap);
+
+               ASSERT_NE(pid, -1);
+               if (pid != 0)
+                       return;
+       }
+
        /*
         * Now move it out of the way so we can place VMAs A, C in position,
         * unfaulted.
@@ -1337,13 +1413,21 @@ TEST_F(merge, mremap_faulted_to_unfaulted_prev_unfaulted_next)
                       &self->carveout[page_size + 3 * page_size]);
        ASSERT_NE(ptr_b, MAP_FAILED);
 
-       /* The VMAs should have merged. */
+       /* The VMAs should have merged, if not forked. */
        ASSERT_TRUE(find_vma_procmap(procmap, ptr_a));
        ASSERT_EQ(procmap->query.vma_start, (unsigned long)ptr_a);
-       ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr_a + 9 * page_size);
+       offset = variant->forked ? 3 * page_size : 9 * page_size;
+       ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr_a + offset);
+
+       /* If forked, B and C should also not have merged. */
+       if (variant->forked) {
+               ASSERT_TRUE(find_vma_procmap(procmap, ptr_b));
+               ASSERT_EQ(procmap->query.vma_start, (unsigned long)ptr_b);
+               ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr_b + 3 * page_size);
+       }
 }
 
-TEST_F(merge, mremap_faulted_to_unfaulted_prev_faulted_next)
+TEST_F(merge_with_fork, mremap_faulted_to_unfaulted_prev_faulted_next)
 {
        struct procmap_fd *procmap = &self->procmap;
        unsigned int page_size = self->page_size;
@@ -1373,6 +1457,14 @@ TEST_F(merge, mremap_faulted_to_unfaulted_prev_faulted_next)
        /* Fault it in. */
        ptr_bc[0] = 'x';
 
+       if (variant->forked) {
+               pid_t pid = do_fork(&self->procmap);
+
+               ASSERT_NE(pid, -1);
+               if (pid != 0)
+                       return;
+       }
+
        /*
         * Now move VMA B out the way (splitting VMA BC) so we can place VMA A
         * in position, unfaulted, and leave the remainder of the VMA we just
@@ -1397,10 +1489,16 @@ TEST_F(merge, mremap_faulted_to_unfaulted_prev_faulted_next)
                       &self->carveout[page_size + 3 * page_size]);
        ASSERT_NE(ptr_b, MAP_FAILED);
 
-       /* The VMAs should have merged. */
-       ASSERT_TRUE(find_vma_procmap(procmap, ptr_a));
-       ASSERT_EQ(procmap->query.vma_start, (unsigned long)ptr_a);
-       ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr_a + 9 * page_size);
+       /* The VMAs should have merged. A,B,C if unforked, B, C if forked. */
+       if (variant->forked) {
+               ASSERT_TRUE(find_vma_procmap(procmap, ptr_b));
+               ASSERT_EQ(procmap->query.vma_start, (unsigned long)ptr_b);
+               ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr_b + 6 * page_size);
+       } else {
+               ASSERT_TRUE(find_vma_procmap(procmap, ptr_a));
+               ASSERT_EQ(procmap->query.vma_start, (unsigned long)ptr_a);
+               ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr_a + 9 * page_size);
+       }
 }
 
 TEST_HARNESS_MAIN