cheritest: minimal capdirty test

Author: nwf

bin/cheritest/cheritest.c

@@ -1059,6 +1059,10 @@ static const struct cheri_test cheri_tests[] = {
 	  .ct_si_trapno = T_TLB_LD_MISS, },
 #endif
 
+	{ .ct_name = "cheritest_vm_capdirty",
+	  .ct_desc = "verify capdirty marking and mincore",
+	  .ct_func = cheritest_vm_capdirty, },
+
 #ifdef CHERI_LIBCHERI_TESTS
 #if 0
 	/*

bin/cheritest/cheritest.h

@@ -560,6 +560,7 @@ DECLARE_CHERI_TEST(cheritest_vm_cow_write);
 DECLARE_CHERI_TEST(test_cloadtags_mapped);
 DECLARE_CHERI_TEST(test_fault_cloadtags_unmapped);
 #endif
+DECLARE_CHERI_TEST(cheritest_vm_capdirty);
 const char	*xfail_need_writable_tmp(const char *name);
 
 #if 0

bin/cheritest/cheritest_vm.c

@@ -656,3 +656,65 @@ test_fault_cloadtags_unmapped(const struct cheri_test *ctp __unused)
 }
 
 #endif
+
+/* Store a cap to a page and check that mincore reports it dirty */
+void
+cheritest_vm_capdirty(const struct cheri_test *ctp __unused)
+{
+	static const size_t npg = 2;
+	size_t sz  = npg * getpagesize();
+
+	void * __capability * pg0;
+	unsigned char mcv[npg] = { 0 };
+
+	pg0 = CHERITEST_CHECK_SYSCALL(mmap(NULL, sz,
+	    PROT_READ | PROT_WRITE, MAP_ANON, -1, 0));
+
+	void * __capability * pg1 = (void *)&((char *)pg0)[getpagesize()];
+
+	CHERITEST_CHECK_SYSCALL(mincore(pg0, sz, &mcv[0]));
+	CHERITEST_VERIFY2(mcv[0] == 0, "page 0 status 0");
+	CHERITEST_VERIFY2(mcv[1] == 0, "page 1 status 0");
+
+	*(char *)pg0 = 0x42;
+
+	CHERITEST_CHECK_SYSCALL(mincore(pg0, sz, &mcv[0]));
+	CHERITEST_VERIFY2((mcv[0] & MINCORE_MODIFIED) != 0, "page 0 modified 1");
+	CHERITEST_VERIFY2((mcv[0] & MINCORE_CAPSTORE) != 0, "page 0 capstore 1");
+	CHERITEST_VERIFY2((mcv[0] & MINCORE_CAPDIRTY) == 0, "page 0 !capdirty 1");
+	CHERITEST_VERIFY2(mcv[1] == 0, "page 1 status 1");
+
+	/*
+	 * To really spot-check what's going on, kick on user-mode tracing.
+	 * Assuming we haven't fast-path'd anything, we should get a series of
+	 * traps from the hardware.  The slowest expected case is something
+	 * like this:
+	 *
+	 *   1. miss  (puts the RO zero page in place)
+	 *   2. write (allocates physical frame)
+	 *   3. capdirty (just sets capdirty bit)
+	 *
+	 * Hardware should merge the first two together, giving us a "miss for
+	 * store" exception that causes the kernel to jump up to the allocated
+	 * physical frame immediately.
+	 *
+	 * CHERI-MIPS defines its capdirty trap to happen only for Valid, Dirty
+	 * entries, so that the capdirty emulation trap does not need to check,
+	 * so at least there there will always be two traps.  Other CHERI archs
+	 * may be able to conflate this down to one trap.
+	 */
+	// CHERI_START_USER_TRACE;
+	*pg1 = (void * __capability)pg0;
+	// CHERI_STOP_USER_TRACE;
+
+	CHERITEST_CHECK_SYSCALL(mincore(pg0, sz, &mcv[0]));
+	CHERITEST_VERIFY2((mcv[0] & MINCORE_MODIFIED) != 0, "page 0 modified 2");
+	CHERITEST_VERIFY2((mcv[0] & MINCORE_CAPSTORE) != 0, "page 0 capstore 2");
+	CHERITEST_VERIFY2((mcv[0] & MINCORE_CAPDIRTY) == 0, "page 0 !capdirty 2");
+	CHERITEST_VERIFY2((mcv[1] & MINCORE_MODIFIED) != 0, "page 1 modified 2");
+	CHERITEST_VERIFY2((mcv[1] & MINCORE_CAPSTORE) != 0, "page 1 capstore 2");
+	CHERITEST_VERIFY2((mcv[1] & MINCORE_CAPDIRTY) != 0, "page 1 capdirty 2");
+
+	CHERITEST_CHECK_SYSCALL(munmap(pg0, sz));
+	cheritest_success();
+}