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

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

test/zdtm/static/maps12.c

@@ -0,0 +1,264 @@
+#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) {
+		pr_perror("setting SIGSEGV handler failed");
+		return 1;
+	}
+
+	/* ensure that try_write_to_addr() works properly */
+	if (!try_write_to_addr(&write_me)) {
+		pr_err("Failed to write at valid addr. Buggy try_write_to_addr()?\n");
+		return 1;
+	}
+
+	if (try_write_to_addr(NULL)) {
+		pr_err("Failed to detect an invalid write. Buggy try_write_to_addr()?\n");
+		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])) {
+			pr_err("successful write to a guarded area %d %s C/R\n",
+			       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)) {
+			pr_err("Page %d is corrupted\n", 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) {
+			pr_err("mmap of [%d,%d] pages failed\n",
+			       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()) {
+		pr_err("setup_sigsegv_handler() failed\n");
+		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) {
+		pr_err("mmap of %d pages failed\n", pages_num);
+		return 1;
+	}
+
+	if (munmap(map_base, pages_num * PAGE_SIZE)) {
+		pr_perror("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()) {
+		pr_err("prepare_vmas() failed\n");
+		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")) {
+		pr_err("check_guards(\"before\") failed\n");
+		return 1;
+	}
+
+	test_daemon();
+	test_waitsig();
+
+	/* ensure that guards are at their places */
+	if (check_guards("after")) {
+		fail("check_guards(\"after\") failed");
+		return 1;
+	}
+
+	/* check that non-guarded pages still contain original data */
+	if (check_pages_data()) {
+		fail("check_pages_data() failed");
+		return 1;
+	}
+
+	pass();
+	munmap(map_base, pages_num * PAGE_SIZE);
+	return 0;
+}

test/zdtm/static/maps12.desc

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