tools/testing/selftests/mm: add MADV_COLLAPSE test case

To ensure the retract_page_tables() logic functions correctly with the
introduction of VM_MAYBE_GUARD, add a test to assert that madvise collapse
fails when guard regions are established in the collapsed range in all
cases.

Unfortunately we cannot differentiate between e.g.
CONFIG_READ_ONLY_THP_FOR_FS not being set vs.  a file-backed VMA having
collapse correctly disallowed, so in each instance we will get an assert
pass here.

We add an additional check to see whether guard regions are preserved
across collapse in case of a bug causing the collapse to succeed, which
will give us more data to debug with should this occur in future.

Link: https://lkml.kernel.org/r/0748beeb864525b8ddfa51adad7128dd32eb3ac4.1763460113.git.lorenzo.stoakes@oracle.com
Signed-off-by: Lorenzo Stoakes <lorenzo.stoakes@oracle.com>
Cc: Andrei Vagin <avagin@gmail.com>
Cc: Baolin Wang <baolin.wang@linux.alibaba.com>
Cc: Barry Song <baohua@kernel.org>
Cc: David Hildenbrand (Red Hat) <david@kernel.org>
Cc: Dev Jain <dev.jain@arm.com>
Cc: Jann Horn <jannh@google.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Lance Yang <lance.yang@linux.dev>
Cc: Liam Howlett <liam.howlett@oracle.com>
Cc: "Masami Hiramatsu (Google)" <mhiramat@kernel.org>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Mike Rapoport <rppt@kernel.org>
Cc: Nico Pache <npache@redhat.com>
Cc: Pedro Falcato <pfalcato@suse.de>
Cc: Ryan Roberts <ryan.roberts@arm.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Zi Yan <ziy@nvidia.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/tools/testing/selftests/mm/guard-regions.c b/tools/testing/selftests/mm/guard-regions.c
index 8dd81c0a4a5a2c25f204e8f40c105505dec8b163..c549bcd6160b5667108d7425ee1f4fd71de9d3db 100644 (file)
--- a/tools/testing/selftests/mm/guard-regions.c
+++ b/tools/testing/selftests/mm/guard-regions.c
@@ -2138,4 +2138,69 @@ TEST_F(guard_regions, pagemap_scan)
        ASSERT_EQ(munmap(ptr, 10 * page_size), 0);
 }
 
+TEST_F(guard_regions, collapse)
+{
+       const unsigned long page_size = self->page_size;
+       const unsigned long size = 2 * HPAGE_SIZE;
+       const unsigned long num_pages = size / page_size;
+       char *ptr;
+       int i;
+
+       /* Need file to be correct size for tests for non-anon. */
+       if (variant->backing != ANON_BACKED)
+               ASSERT_EQ(ftruncate(self->fd, size), 0);
+
+       /*
+        * We must close and re-open local-file backed as read-only for
+        * CONFIG_READ_ONLY_THP_FOR_FS to work.
+        */
+       if (variant->backing == LOCAL_FILE_BACKED) {
+               ASSERT_EQ(close(self->fd), 0);
+
+               self->fd = open(self->path, O_RDONLY);
+               ASSERT_GE(self->fd, 0);
+       }
+
+       ptr = mmap_(self, variant, NULL, size, PROT_READ, 0, 0);
+       ASSERT_NE(ptr, MAP_FAILED);
+
+       /* Prevent being faulted-in as huge. */
+       ASSERT_EQ(madvise(ptr, size, MADV_NOHUGEPAGE), 0);
+       /* Fault in. */
+       ASSERT_EQ(madvise(ptr, size, MADV_POPULATE_READ), 0);
+
+       /* Install guard regions in ever other page. */
+       for (i = 0; i < num_pages; i += 2) {
+               char *ptr_page = &ptr[i * page_size];
+
+               ASSERT_EQ(madvise(ptr_page, page_size, MADV_GUARD_INSTALL), 0);
+               /* Accesses should now fail. */
+               ASSERT_FALSE(try_read_buf(ptr_page));
+       }
+
+       /* Allow huge page throughout region. */
+       ASSERT_EQ(madvise(ptr, size, MADV_HUGEPAGE), 0);
+
+       /*
+        * Now collapse the entire region. This should fail in all cases.
+        *
+        * The madvise() call will also fail if CONFIG_READ_ONLY_THP_FOR_FS is
+        * not set for the local file case, but we can't differentiate whether
+        * this occurred or if the collapse was rightly rejected.
+        */
+       EXPECT_NE(madvise(ptr, size, MADV_COLLAPSE), 0);
+
+       /*
+        * If we introduce a bug that causes the collapse to succeed, gather
+        * data on whether guard regions are at least preserved. The test will
+        * fail at this point in any case.
+        */
+       for (i = 0; i < num_pages; i += 2) {
+               char *ptr_page = &ptr[i * page_size];
+
+               /* Accesses should still fail. */
+               ASSERT_FALSE(try_read_buf(ptr_page));
+       }
+}
+
 TEST_HARNESS_MAIN