test/zdtm/static: add madv guards test

Test for madvise(MADV_GUARD_INSTALL).

Signed-off-by: Alexander Mikhalitsyn <aleksandr.mikhalitsyn@canonical.com>

Author: mihalicyn

test/zdtm/static/Makefile

@@ -150,6 +150,7 @@ TST_NOFILE	:=				\
 		maps05				\
 		maps09				\
 		maps10				\
+		maps11				\
 		mlock_setuid			\
 		xids00				\
 		groups				\

test/zdtm/static/maps11.c

@@ -0,0 +1,246 @@
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <setjmp.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <linux/limits.h>
+#include "zdtmtst.h"
+
+const char *test_doc = "Test madvise(MADV_GUARD_INSTALL)";
+const char *test_author = "Alexander Mikhalitsyn <aleksandr.mikhalitsyn@canonical.com>";
+/* some parts of code were taken from Linux kernel's kselftest guard-pages.c
+   written by Lorenzo Stoakes <lorenzo.stoakes@oracle.com> */
+
+#ifndef MADV_GUARD_INSTALL
+#define MADV_GUARD_INSTALL 102
+#endif
+
+uint8_t *map_base;
+
+struct {
+	unsigned int pages_num;
+} vmas[] = {
+	{ 2 },
+	{ 2 },
+	{ 2 },
+	{ 2 },
+	{ 2 },
+};
+
+struct {
+	bool guarded;
+} pages[] = {
+	{ false },
+	{ true },
+	{ true },
+	{ false },
+	{ false },
+	{ true },
+	{ true },
+	{ false },
+	{ false },
+	{ false },
+};
+
+static volatile sig_atomic_t signal_jump_set;
+static sigjmp_buf signal_jmp_buf;
+
+static void handle_sigsegv(int signo)
+{
+	if (!signal_jump_set)
+		return;
+
+	siglongjmp(signal_jmp_buf, 1);
+}
+
+static bool try_write_to_addr(uint8_t *ptr)
+{
+	bool failed;
+
+	/* Tell signal handler to jump back here on fatal signal. */
+	signal_jump_set = true;
+	/* If a fatal signal arose, we will jump back here and failed is set. */
+	failed = sigsetjmp(signal_jmp_buf, 1) != 0;
+
+	if (!failed)
+		*ptr = 'x';
+
+	signal_jump_set = false;
+	return !failed;
+}
+
+static int setup_sigsegv_handler(void)
+{
+	uint8_t write_me;
+
+	if (signal(SIGSEGV, handle_sigsegv) == SIG_ERR) {
+		fail("setting SIGSEGV handler failed");
+		return 1;
+	}
+
+	/* ensure that try_write_to_addr() works properly */
+	if (!try_write_to_addr(&write_me)) {
+		fail("Failed to write at valid addr. Buggy try_write_to_addr()?");
+		return 1;
+	}
+
+	if (try_write_to_addr(NULL)) {
+		fail("Failed to detect an invalid write. Buggy try_write_to_addr()?");
+		return 1;
+	}
+
+	return 0;
+}
+
+static inline void *mmap_pages(void *addr_hint, unsigned int count)
+{
+	char *map;
+
+	map = mmap(addr_hint, count * PAGE_SIZE, PROT_WRITE | PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+	if (map == MAP_FAILED || (addr_hint && (map != addr_hint)))
+		return MAP_FAILED;
+
+	return map;
+}
+
+static int check_guards(const char *when)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(pages); i++) {
+		if (!pages[i].guarded)
+			continue;
+
+		if (try_write_to_addr(&map_base[i * PAGE_SIZE])) {
+			fail("successful write to a guarded area %d %s C/R", i, when);
+			return 1;
+		}
+	}
+
+	return 0;
+}
+
+static void gen_pages_data(void)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(pages); i++) {
+		uint32_t crc;
+
+		if (pages[i].guarded)
+			continue;
+
+		crc = ~0;
+		datagen(&map_base[i * PAGE_SIZE], PAGE_SIZE, &crc);
+	}
+}
+
+static int check_pages_data(void)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(pages); i++) {
+		uint32_t crc;
+
+		if (pages[i].guarded)
+			continue;
+
+		crc = ~0;
+		if (datachk(&map_base[i * PAGE_SIZE], PAGE_SIZE, &crc)) {
+			fail("Page %d is corrupted", i);
+			return 1;
+		}
+	}
+
+	return 0;
+}
+
+static int prepare_vmas(void)
+{
+	char *map;
+	int i, shift;
+
+	shift = 0;
+	for (i = 0; i < ARRAY_SIZE(vmas); i++) {
+		map = mmap_pages(&map_base[shift * PAGE_SIZE], vmas[i].pages_num);
+		if (map == MAP_FAILED) {
+			fail("mmap of [%d,%d] pages failed", shift, shift + vmas[i].pages_num);
+			return 1;
+		}
+
+		shift += vmas[i].pages_num;
+	}
+
+	return 0;
+}
+
+int main(int argc, char **argv)
+{
+	unsigned int pages_num = ARRAY_SIZE(pages);
+
+	test_init(argc, argv);
+
+	if (setup_sigsegv_handler())
+		return 1;
+
+	/*
+	 * ToDo:
+	 * - handle VM_WIPEONFORK in CRIU and test it too
+	 * - ...
+	 */
+
+	/* let's find a large enough area in address space */
+	map_base = mmap_pages(NULL, pages_num);
+	if (map_base == MAP_FAILED) {
+		fail("mmap of %d pages failed", pages_num);
+		return 1;
+	}
+
+	if (munmap(map_base, pages_num * PAGE_SIZE)) {
+		fail("munmap failed");
+		return 1;
+	}
+
+	/* Now we know that we have a free vm address space area [map_base, map_base + pages_num * PAGE_SIZE).
+	 * We can use (map_base) as a hint for our further mmaps.
+	 */
+	if (prepare_vmas())
+		return 1;
+
+	/* fill non-guarded pages with data and preserve checksums */
+	gen_pages_data();
+
+	/* guard pages {2,3} */
+	if (madvise(&map_base[1 * PAGE_SIZE], 2 * PAGE_SIZE, MADV_GUARD_INSTALL)) {
+		pr_perror("madvise failed");
+		return 1;
+	}
+
+	/* guard pages {6,7} */
+	if (madvise(&map_base[5 * PAGE_SIZE], 2 * PAGE_SIZE, MADV_GUARD_INSTALL)) {
+		pr_perror("madvise failed");
+		return 1;
+	}
+
+	/* ensure that madvise(MADV_GUARD_INSTALL) works like expected */
+	if (check_guards("before"))
+		return 1;
+
+	test_daemon();
+	test_waitsig();
+
+	/* ensure that guards are at their places */
+	if (check_guards("after"))
+		return 1;
+
+	/* check that non-guarded pages still contain original data */
+	if (check_pages_data())
+		return 1;
+
+	pass();
+	munmap(map_base, pages_num * PAGE_SIZE);
+	return 0;
+}

test/zdtm/static/maps11.desc

@@ -0,0 +1 @@
+{'flavor': 'h', 'feature': 'pagemap_scan_guard_pages'}