Basic qemu eviction test with signalled stepping and added rip syscall

10 files changed, 190 insertions, 428 deletions

diff --git a/test/kvm-eviction.c b/test/kvm-eviction.c
index cc1fbe3..02830fd 100644
--- a/test/kvm-eviction.c
+++ b/test/kvm-eviction.c
@@ -28,10 +28,10 @@ collect(struct kvm *kvm, uint8_t *counts)
 
 	if (kvm->run->exit_reason == KVM_EXIT_MMIO) {
 		errx(1, "KVM died from OOB access! rip:%lu addr:%lu",
-			vm_get_rip(kvm), kvm->run->mmio.phys_addr);
+			vm_get_rip(), kvm->run->mmio.phys_addr);
 	} else if (kvm->run->exit_reason != KVM_EXIT_HLT) {
 		errx(1, "KVM died! rip:%lu code:%i",
-			vm_get_rip(kvm), kvm->run->exit_reason);
+			vm_get_rip(), kvm->run->exit_reason);
 	}
 
 	ret = ioctl(kvm_dev, KVM_CPC_READ_COUNTS, counts);
@@ -45,6 +45,7 @@ main(int argc, const char **argv)
 	struct guest guests[2];
 	uint8_t counts[2][SAMPLE_COUNT][L1_SETS];
 	uint8_t baseline[L1_SETS];
+	uint32_t arg;
 	int i, k, ret;
 
 	vmtype = "kvm";
@@ -72,8 +73,9 @@ main(int argc, const char **argv)
 	ret = ioctl(kvm_dev, KVM_CPC_RESET);
 	if (ret == -1) err(1, "KVM_CPC_RESET");
 
-	ret = ioctl(kvm_dev, KVM_CPC_LONG_STEP);
-	if (ret == -1) err(1, "KVM_CPC_LONG_STEP");
+	arg = CPC_TRACK_EXIT_EVICTIONS;
+	ret = ioctl(kvm_dev, KVM_CPC_TRACK_MODE, &arg);
+	if (ret == -1) err(1, "KVM_CPC_TRACK_MODE");
 
 	/* resolve page faults in advance (code only covers 1 page)..
 	 * we want the read counts to apply between KVM_RUN and KVM_EXIT_HLT,
diff --git a/test/guest.lds b/test/kvm-guest.lds
index bced66e..bced66e 100644
--- a/test/guest.lds
+++ b/test/kvm-guest.lds
diff --git a/test/kvm-pagestep.c b/test/kvm-pagestep.c
index 5f9d025..4bd4ac0 100644
--- a/test/kvm-pagestep.c
+++ b/test/kvm-pagestep.c
@@ -29,18 +29,18 @@ monitor(struct kvm *kvm, bool baseline)
 	/* Get page fault info */
 	ret = ioctl(kvm_dev, KVM_CPC_POLL_EVENT, &event);
 	if (ret && errno == EAGAIN) return 0;
-	if (ret) err(1, "ioctl KVM_CPC_POLL_EVENT");
+	if (ret) err(1, "KVM_CPC_POLL_EVENT");
 
 	if (event.type != CPC_EVENT_TRACK_PAGE)
 		errx(1, "unexpected event type %i", event.type);
 
 	printf("Event: rip:%08llx prev:%llu next:%llu ret:%llu\n",
-		vm_get_rip(kvm), event.page.inst_gfn_prev,
+		vm_get_rip(), event.page.inst_gfn_prev,
 		event.page.inst_gfn, event.page.retinst);
 	printf("\n");
 
 	ret = ioctl(kvm_dev, KVM_CPC_ACK_EVENT, &event.id);
-	if (ret) err(1, "ioctl KVM_CPC_ACK_EVENT");
+	if (ret) err(1, "KVM_CPC_ACK_EVENT");
 
 	return 1;
 }
@@ -86,7 +86,7 @@ main(int argc, const char **argv)
 
 		/* reset kernel module state */
 		ret = ioctl(kvm_dev, KVM_CPC_RESET, NULL);
-		if (ret < 0) err(1, "ioctl KVM_CPC_RESET");
+		if (ret < 0) err(1, "KVM_CPC_RESET");
 
 		ipc_signal_parent(ipc);
 		ipc_wait_parent(ipc);
@@ -113,9 +113,9 @@ main(int argc, const char **argv)
 
 		printf("Monitor start\n");
 
-		arg = CPC_TRACK_EXEC;
+		arg = CPC_TRACK_PAGES;
 		ret = ioctl(kvm_dev, KVM_CPC_TRACK_MODE, &arg);
-		if (ret) err(1, "ioctl KVM_CPC_TRACK_MODE");
+		if (ret) err(1, "KVM_CPC_TRACK_MODE");
 
 		ipc_signal_child(ipc);
 
diff --git a/test/kvm-step.c b/test/kvm-step.c
index 9fefb5e..aec1aaf 100644
--- a/test/kvm-step.c
+++ b/test/kvm-step.c
@@ -24,22 +24,21 @@ static struct cpc_event event;
 uint64_t
 monitor(struct kvm *kvm, bool baseline)
 {
-	uint8_t counts[64];
+	uint8_t counts[L1_SETS];
 	int ret;
 
-	/* Get page fault info */
 	ret = ioctl(kvm_dev, KVM_CPC_POLL_EVENT, &event);
 	if (ret && errno == EAGAIN) return 0;
-	if (ret) err(1, "ioctl KVM_CPC_POLL_EVENT");
+	if (ret) err(1, "KVM_CPC_POLL_EVENT");
 
 	if (event.type != CPC_EVENT_TRACK_STEP)
 		errx(1, "unexpected event type %i", event.type);
 
 	ret = ioctl(kvm_dev, KVM_CPC_READ_COUNTS, counts);
-	if (ret) err(1, "ioctl KVM_CPC_READ_COUNTS");
+	if (ret) err(1, "KVM_CPC_READ_COUNTS");
 
 	printf("Event: rip:%llu cnt:%llu inst:%llu data:%llu ret:%llu\n",
-		vm_get_rip(kvm), event.step.fault_count,
+		vm_get_rip(), event.step.fault_count,
 		event.step.fault_gfns[0], event.step.fault_gfns[1],
 		event.step.retinst);
 	print_counts(counts);
@@ -48,7 +47,7 @@ monitor(struct kvm *kvm, bool baseline)
 	printf("\n");
 
 	ret = ioctl(kvm_dev, KVM_CPC_ACK_EVENT, &event.id);
-	if (ret) err(1, "ioctl KVM_CPC_ACK_EVENT");
+	if (ret) err(1, "KVM_CPC_ACK_EVENT");
 
 	return 1;
 }
@@ -96,7 +95,7 @@ main(int argc, const char **argv)
 
 		/* reset kernel module state */
 		ret = ioctl(kvm_dev, KVM_CPC_RESET, NULL);
-		if (ret < 0) err(1, "ioctl KVM_CPC_RESET");
+		if (ret < 0) err(1, "KVM_CPC_RESET");
 
 		ipc_signal_parent(ipc);
 		ipc_wait_parent(ipc);
@@ -123,15 +122,14 @@ main(int argc, const char **argv)
 
 		printf("Monitor start\n");
 
-		/* capture baseline by just letting it fault over and over */
-		arg = CPC_TRACK_FAULT_NO_RUN;
+		/* single step and log all accessed pages */
+		arg = CPC_TRACK_STEPS;
 		ret = ioctl(kvm_dev, KVM_CPC_TRACK_MODE, &arg);
-		if (ret) err(1, "ioctl KVM_CPC_TRACK_MODE");
+		if (ret) err(1, "KVM_CPC_TRACK_MODE");
 
-		/* calculate baseline while running vm */
 		arg = true;
 		ret = ioctl(kvm_dev, KVM_CPC_CALC_BASELINE, &arg);
-		if (ret) err(1, "ioctl KVM_CPC_CALC_BASELINE");
+		if (ret) err(1, "KVM_CPC_CALC_BASELINE");
 
 		ipc_signal_child(ipc);
 
@@ -141,30 +139,30 @@ main(int argc, const char **argv)
 			eventcnt += monitor(&kvm, true);
 		}
 
-		printf("Req pause\n");
+		printf("Monitor req pause\n");
 		ret = ioctl(kvm_dev, KVM_CPC_VM_REQ_PAUSE);
-		if (ret) err(1, "ioctl KVM_CPC_VM_REQ_PAUSE");
+		if (ret) err(1, "KVM_CPC_VM_REQ_PAUSE");
 
 		while (1) {
 			printf("Monitor Polling\n");
 			ret = ioctl(kvm_dev, KVM_CPC_POLL_EVENT, &event);
 			if (ret && errno == EAGAIN) continue;
-			if (ret) err(1, "ioctl KVM_CPC_POLL_EVENT");
+			if (ret) err(1, "KVM_CPC_POLL_EVENT");
 			printf("Monitor Event\n");
 
 			if (event.type == CPC_EVENT_PAUSE) break;
 
 			printf("Skipping non-pause event..\n");
 			ret = ioctl(kvm_dev, KVM_CPC_ACK_EVENT, &event.id);
-			if (ret) err(1, "ioctl KVM_CPC_ACK_EVENT");
+			if (ret) err(1, "KVM_CPC_ACK_EVENT");
 		}
 
 		arg = false;
 		ret = ioctl(kvm_dev, KVM_CPC_CALC_BASELINE, &arg);
-		if (ret) err(1, "ioctl KVM_CPC_CALC_BASELINE");
+		if (ret) err(1, "KVM_CPC_CALC_BASELINE");
 
 		ret = ioctl(kvm_dev, KVM_CPC_READ_BASELINE, baseline);
-		if (ret) err(1, "ioctl KVM_CPC_READ_BASELINE");
+		if (ret) err(1, "KVM_CPC_READ_BASELINE");
 
 		printf("\nBaseline:\n");
 		print_counts(baseline);
@@ -174,15 +172,10 @@ main(int argc, const char **argv)
 
 		arg = true;
 		ret = ioctl(kvm_dev, KVM_CPC_APPLY_BASELINE, &arg);
-		if (ret) err(1, "ioctl KMV_CPC_APPLY_BASELINE");
-
-		/* single step and log all accessed pages */
-		arg = CPC_TRACK_FULL;
-		ret = ioctl(kvm_dev, KVM_CPC_TRACK_MODE, &arg);
-		if (ret) err(1, "ioctl KVM_CPC_TRACK_MODE");
+		if (ret) err(1, "KMV_CPC_APPLY_BASELINE");
 
 		ret = ioctl(kvm_dev, KVM_CPC_ACK_EVENT, &event.id);
-		if (ret) err(1, "ioctl KVM_CPC_ACK_EVENT");
+		if (ret) err(1, "KVM_CPC_ACK_EVENT");
 
 		eventcnt = 0;
 		while (eventcnt < 50) {
diff --git a/test/kvm.c b/test/kvm.c
index b2b28fe..d50e4fe 100644
--- a/test/kvm.c
+++ b/test/kvm.c
@@ -100,8 +100,13 @@ sev_ioctl(int vmfd, int cmd, void *data, int *error)
 	input.sev_fd = sev_dev;
 	input.data = (uintptr_t) data;
 
-	ret = ioctl(vmfd, KVM_MEMORY_ENCRYPT_OP, &input);
-	if (error) *error = input.error;
+	if (vmfd == MAIN_VMFD) {
+		ret = ioctl(kvm_dev, KVM_CPC_MEMORY_ENCRYPT_OP, &input);
+		if (error) *error = input.error;
+	} else {
+		ret = ioctl(vmfd, KVM_MEMORY_ENCRYPT_OP, &input);
+		if (error) *error = input.error;
+	}
 
 	return ret;
 }
@@ -144,66 +149,6 @@ sev_guest_state(int vmfd, uint32_t handle)
 }
 
 void
-sev_dbg_decrypt(int vmfd, void *src, void *dst, size_t size)
-{
-	struct kvm_sev_dbg enc;
-	int ret, fwerr;
-
-	enc.src_uaddr = (uintptr_t) src;
-	enc.dst_uaddr = (uintptr_t) dst;
-	enc.len = size;
-	ret = sev_ioctl(vmfd, KVM_SEV_DBG_DECRYPT, &enc, &fwerr);
-	if (ret == -1) errx(1, "KVM_SEV_DBG_DECRYPT: (%s) %s",
-		strerror(errno), sev_fwerr_str(fwerr));
-}
-
-uint64_t
-sev_dbg_decrypt_rip(int vmfd)
-{
-	uint8_t vmsa[PAGE_SIZE];
-	uint64_t rip;
-
-	memset(vmsa, 0, PAGE_SIZE);
-	sev_dbg_decrypt(vmfd, vmsa, CPC_VMSA_MAGIC_ADDR, PAGE_SIZE);
-
-	rip = *(uint64_t *)(vmsa + 0x178);
-
-	return rip;
-}
-
-void
-snp_dbg_decrypt(int vmfd, void *src, void *dst, size_t size)
-{
-	struct kvm_sev_dbg enc;
-	int ret, fwerr;
-
-	assert(src == CPC_VMSA_MAGIC_ADDR);
-
-	memset(&enc, 0, sizeof(struct kvm_sev_dbg));
-	enc.src_uaddr = (uintptr_t) src;
-	enc.dst_uaddr = (uintptr_t) dst;
-	enc.len = size;
-
-	ret = sev_ioctl(vmfd, KVM_SEV_DBG_DECRYPT, &enc, &fwerr);
-	if (ret < 0) errx(1, "KVM_SEV_DBG_DECRYPT: (%s) %s",
-		strerror(errno), sev_fwerr_str(fwerr));
-}
-
-uint64_t
-snp_dbg_decrypt_rip(int vmfd)
-{
-	uint8_t vmsa[PAGE_SIZE];
-	uint64_t rip;
-
-	memset(vmsa, 0, PAGE_SIZE);
-	snp_dbg_decrypt(vmfd, CPC_VMSA_MAGIC_ADDR, vmsa, PAGE_SIZE);
-
-	rip = *(uint64_t *)(vmsa + 0x178);
-
-	return rip;
-}
-
-void
 guest_init(struct guest *guest, const char *filename)
 {
 	FILE *f;
@@ -487,6 +432,20 @@ kvm_deinit(struct kvm *kvm)
 	munmap(kvm->run, kvm->runsize);
 }
 
+uint64_t
+vm_get_rip(void)
+{
+	struct cpc_sev_cmd cmd;
+	int ret, fwerr;
+
+	cmd.id = SEV_CPC_GET_RIP;
+	ret = sev_ioctl(MAIN_VMFD, KVM_SEV_CACHEPC, &cmd, &fwerr);
+	if (ret == -1) errx(1, "KVM_SEV_CACHEPC: (%s) %s",
+		strerror(errno), sev_fwerr_str(fwerr));
+
+	return cmd.data;
+}
+
 void
 parse_vmtype(int argc, const char **argv)
 {
@@ -498,26 +457,6 @@ parse_vmtype(int argc, const char **argv)
 		errx(1, "invalid vm mode: %s", vmtype);
 }
 
-uint64_t
-vm_get_rip(struct kvm *kvm)
-{
-	struct kvm_regs regs;
-	uint64_t rip;
-	int ret;
-
-	if (!strcmp(vmtype, "sev-snp")) {
-		rip = snp_dbg_decrypt_rip(kvm->vmfd);
-	} else if (!strcmp(vmtype, "sev-es")) {
-		rip = sev_dbg_decrypt_rip(kvm->vmfd);
-	} else {
-		ret = ioctl(kvm_dev, KVM_CPC_GET_REGS, &regs);
-		if (ret == -1) err(1, "KVM_CPC_GET_REGS");
-		rip = regs.rip;
-	}
-
-	return rip;
-}
-
 void
 vm_init(struct kvm *kvm, struct guest *guest)
 {
diff --git a/test/kvm.h b/test/kvm.h
index 58e164e..da1a146 100644
--- a/test/kvm.h
+++ b/test/kvm.h
@@ -5,6 +5,8 @@
 #include <stdint.h>
 #include <stdlib.h>
 
+#define MAIN_VMFD -0x42
+
 enum { WITH, WITHOUT };
 
 enum {
@@ -36,10 +38,6 @@ const char *sev_gstate_str(int code);
 int sev_ioctl(int vmfd, int cmd, void *data, int *error);
 void sev_get_measure(int vmfd);
 uint8_t sev_guest_state(int vmfd, uint32_t handle);
-void sev_dbg_decrypt(int vmfd, void *src, void *dst, size_t size);
-uint64_t sev_dbg_decrypt_rip(int vmfd);
-void snp_dbg_decrypt(int vmfd, void *src, void *dst, size_t size);
-uint64_t snp_dbg_decrypt_rip(int vmfd);
 
 void guest_init(struct guest *guest, const char *filename);
 void guest_deinit(struct guest *guest);
@@ -50,8 +48,8 @@ void sev_es_kvm_init(struct kvm *kvm, struct guest *guest);
 void sev_snp_kvm_init(struct kvm *kvm, struct guest *guest);
 void kvm_deinit(struct kvm *kvm);
 
+uint64_t vm_get_rip(void);
 void parse_vmtype(int argc, const char **argv);
-uint64_t vm_get_rip(struct kvm *kvm);
 void vm_init(struct kvm *kvm, struct guest *guest);
 void vm_deinit(struct kvm *kvm);
 
diff --git a/test/qemu-eviction.c b/test/qemu-eviction.c
index 2761d8c..a602bef 100644
--- a/test/qemu-eviction.c
+++ b/test/qemu-eviction.c
@@ -1,361 +1,151 @@
-#define _GNU_SOURCE
-
+#include "test/kvm-eviction.h"
+#include "test/kvm.h"
+#include "test/util.h"
 #include "cachepc/uapi.h"
 
-#include <linux/psp-sev.h>
-#include <linux/kvm.h>
-#include <sys/syscall.h>
-#include <sys/ioctl.h>
-#include <sys/user.h>
-#include <sys/wait.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
 #include <signal.h>
-#include <dirent.h>
-#include <assert.h>
+#include <unistd.h>
+#include <fcntl.h>
 #include <errno.h>
 #include <err.h>
-#include <fcntl.h>
-#include <sched.h>
-#include <dirent.h>
 #include <string.h>
 #include <stdbool.h>
-#include <stdlib.h>
-#include <stdint.h>
 #include <stdio.h>
-#include <stdarg.h>
-
-#define ARRLEN(x) (sizeof(x) / sizeof((x)[0]))
-#define MIN(a,b) ((a) > (b) ? (b) : (a))
+#include <stdlib.h>
 
 #define TARGET_CORE 2
 #define SECONDARY_CORE 3
 
-#define TARGET_SET 15
-
-/* ioctl dev fds */
-static int kvm_dev;
-static int faultcnt;
-
-void
-hexdump(void *data, int len)
-{
-	int i;
-
-	for (i = 0; i < len; i++) {
-		if (i % 16 == 0 && i)
-			printf("\n");
-		printf("%02X ", *(uint8_t *)(data + i));
-	}
-	printf("\n");
-}
-
-bool
-pin_process(pid_t pid, int cpu, bool assert)
-{
-	cpu_set_t cpuset;
-	int ret;
-
-	CPU_ZERO(&cpuset);
-	CPU_SET(cpu, &cpuset);
-	ret = sched_setaffinity(pid, sizeof(cpu_set_t), &cpuset);
-	if (ret < 0) {
-		if (assert) err(1, "sched_setaffinity");
-		return false;
-	}
-
-	return true;
-}
-
-cpc_msrmt_t *
-read_counts()
-{
-	cpc_msrmt_t *counts;
-	int i, ret;
-
-	counts = malloc(L1_SETS * sizeof(cpc_msrmt_t));
-	if (!counts) err(1, "malloc");
-
-	ret = ioctl(kvm_dev, KVM_CPC_READ_COUNTS, counts);
-	if (ret) err(1, "ioctl READ_COUNTS");
-
-	for (i = 0; i < L1_SETS; i++) {
-		if (counts[i] > 8)
-			errx(1, "Invalid counts set %i", i);
-	}	
-
-	return counts;
-}
-
-void
-print_counts(cpc_msrmt_t *counts)
-{
-	int i;
-
-	for (i = 0; i < 64; i++) {
-		if (i % 16 == 0 && i)
-			printf("\n");
-		if (counts[i] == 1)
-			printf("\x1b[38;5;88m");
-		else if (counts[i] > 1)
-			printf("\x1b[38;5;196m");
-		printf("%2i ", i);
-		if (counts[i] > 0)
-			printf("\x1b[0m");
-	}
-	printf("\n");
-}
-
-void
-print_counts_raw(cpc_msrmt_t *counts)
-{
-	int i;
-
-	for (i = 0; i < 64; i++) {
-		if (i % 16 == 0 && i)
-			printf("\n");
-		if (counts[i] == 1)
-			printf("\x1b[38;5;88m");
-		else if (counts[i] > 1)
-			printf("\x1b[38;5;196m");
-		printf("%02X ", (uint8_t) counts[i]);
-		if (counts[i] > 0)
-			printf("\x1b[0m");
-	}
-	printf("\n");
-}
+static struct cpc_event event;
 
 int
 monitor(bool baseline)
 {
-	struct cpc_event event;
-	cpc_msrmt_t counts[64];
-	uint64_t inst_fault_gfn;
-	uint64_t read_fault_gfn;
-	uint64_t arg;
-	int ret, i;
-
-	/* Get page fault info */
-	ret = ioctl(kvm_dev, KVM_CPC_POLL_EVENT, &event);
-	if (ret) {
-		if (errno == EAGAIN)
-			return 0;
-		perror("ioctl POLL_EVENT");
-		return 1;
-	}
-
-	if (event.type == CPC_EVENT_CPUID) {
-		printf("CPUID EVENT\n");
-		if (event.guest.type == CPC_GUEST_START_TRACK) {
-			ret = ioctl(kvm_dev, KVM_CPC_TRACK_EXEC_CUR, &inst_fault_gfn);
-			if (ret) err(1, "ioctl TRACK_EXEC_CUR");
-
-			printf("CPUID INST PAGE: %lu\n", inst_fault_gfn);
-
-			arg = inst_fault_gfn;
-			ret = ioctl(kvm_dev, KVM_CPC_TRACK_RANGE_START, &arg);
-			if (ret) err(1, "ioctl TRACK_RANGE_START");
-
-			arg = inst_fault_gfn+8;
-			ret = ioctl(kvm_dev, KVM_CPC_TRACK_RANGE_END, &arg);
-			if (ret) err(1, "ioctl TRACK_RANGE_END");
-		} else if (event.guest.type == CPC_GUEST_STOP_TRACK) {
-			arg = 0;
-			ret = ioctl(kvm_dev, KVM_CPC_TRACK_RANGE_START, &arg);
-			if (ret) err(1, "ioctl TRACK_RANGE_START");
-
-			arg = 0;
-			ret = ioctl(kvm_dev, KVM_CPC_TRACK_RANGE_END, &arg);
-			if (ret) err(1, "ioctl TRACK_RANGE_END");
-		}
-
-		faultcnt++;
-	} else if (event.type == CPC_EVENT_TRACK_STEP) {
-		printf("STEP EVENT\n");
+	uint8_t counts[L1_SETS];
+	int ret;
 
+	ret = ioctl(kvm_dev, KVM_CPC_POLL_EVENT, &event);
+	if (ret && errno == EAGAIN) return 0;
+	if (ret) err(1, "KVM_CPC_POLL_EVENT");
+
+	switch (event.type) {
+	case CPC_EVENT_GUEST:
+		if (event.guest.type == CPC_GUEST_STOP_TRACK)
+			return 2;
+		break;
+	case CPC_EVENT_TRACK_STEP:
 		ret = ioctl(kvm_dev, KVM_CPC_READ_COUNTS, counts);
-		if (ret) err(1, "ioctl READ_COUNTS");
-
-		inst_fault_gfn = 0;
-		read_fault_gfn = 0;
-		for (i = 0; i < event.step.fault_count; i++) {
-			if ((event.step.fault_errs[i] & 0b11111) == 0b10100)
-				inst_fault_gfn = event.step.fault_gfns[i];
-			else if ((event.step.fault_errs[i] & 0b00110) == 0b00100)
-				read_fault_gfn = event.step.fault_gfns[i];
-		}
-
-		if (!baseline) {
-			printf("Event: cnt:%llu inst:%lu data:%lu retired:%llu\n",
-				event.step.fault_count, inst_fault_gfn,
-				read_fault_gfn, event.step.retinst);
-			print_counts(counts);
-			printf("\n");
-		}
-
-		for (i = 0; i < 64; i++) {
-			if (counts[i] > 8) {
-				warnx("Invalid count for set %i (%llu)",
-					i, counts[i]);
-				counts[i] = 8;
-			}
-		}
-
-		if (baseline) faultcnt++;
-	} else if (event.type == CPC_EVENT_TRACK_PAGE) {
-		printf("PAGE EVENT\n");
-
-		printf("Event: prev:%llu new:%llu retired:%llu\n",
-			event.page.inst_gfn_prev, event.page.inst_gfn,
-		       	event.page.retinst);
+		if (ret) err(1, "KVM_CPC_READ_COUNTS");
+
+		printf("Event: rip:%016llx cnt:%llu "
+			"inst:%08llu data:%08llx ret:%llu\n",
+			vm_get_rip(), event.step.fault_count,
+			event.step.fault_gfns[0], event.step.fault_gfns[1],
+			event.step.retinst);
+		print_counts(counts);
+		printf("\n");
+		print_counts_raw(counts);
+		printf("\n");
+		break;
+	default:
+		errx(1, "unexpected event type %i", event.type);
 	}
 
 	ret = ioctl(kvm_dev, KVM_CPC_ACK_EVENT, &event.id);
-	if (ret) err(1, "ioctl ACK_EVENT");
+	if (ret) err(1, "KVM_CPC_ACK_EVENT");
 
-	return 0;
+	return 1;
 }
 
-int
-pgrep(const char *bin)
+void
+reset(int sig)
 {
-	char path[PATH_MAX];
-	char buf[PATH_MAX];
-	char *cmp;
-	struct dirent *ent;
-	FILE *f;
-	DIR *dir;
-
-	dir = opendir("/proc");
-	if (!dir) err(1, "opendir");
-
-	while ((ent = readdir(dir))) {
-		snprintf(path, sizeof(path), "/proc/%s/cmdline", ent->d_name);
-		f = fopen(path, "rb");
-		if (!f) continue;
-		memset(buf, 0, sizeof(buf));
-		fread(buf, 1, sizeof(buf), f);
-		if ((cmp = strrchr(buf, '/')))
-			cmp += 1;
-		else
-			cmp = buf;
-		if (!strcmp(cmp, bin))
-			return atoi(ent->d_name);
-		fclose(f);
-	}
-
-	closedir(dir);
+	int ret;
 
-	return 0;
+	ret = ioctl(kvm_dev, KVM_CPC_RESET);
+	if (ret) err(1, "KVM_CPC_RESET");
 }
 
 int
 main(int argc, const char **argv)
 {
-	pid_t pid;
+	uint8_t baseline[L1_SETS];
+	uint32_t eventcnt;
 	uint32_t arg;
-	struct cpc_event event;
-	cpc_msrmt_t baseline[64];
-	int ret, i;
-
-	kvm_setup_init();
-
-	setvbuf(stdout, NULL, _IONBF, 0);
-
-	pid = pgrep("qemu-system-x86_64");
-	if (!pid) errx(1, "Failed to find qemu instance");
-	printf("PID %i\n", pid);
+	pid_t qemu;
+	int ret;
 
-	pin_process(pid, TARGET_CORE, true);
-	pin_process(0, TARGET_CORE, true);
+	qemu = pgrep("qemu-system-x86_64");
+	if (!qemu) errx(1, "pgrep failed");
 
-	/* Setup needed performance counters */
-	ret = ioctl(kvm_dev, KVM_CPC_SETUP_PMC, NULL);
-	if (ret < 0) err(1, "ioctl SETUP_PMC");
+	pin_process(0, SECONDARY_CORE, true);
 
-	/* Reset previous tracking */
-	ret = ioctl(kvm_dev, KVM_CPC_RESET_TRACKING, NULL);
-	if (ret) err(1, "ioctl RESET_TRACKING");
+	setvbuf(stdout, NULL, _IONBF, 0);
 
-	pin_process(0, SECONDARY_CORE, true);
-	printf("PINNED\n");
+	kvm_setup_init();
 
-	// arg = false;
-	// ret = ioctl(kvm_dev, KVM_CPC_SUB_BASELINE, &arg);
-	// if (ret) err(1, "ioctl SUB_BASELINE");
+	ret = ioctl(kvm_dev, KVM_CPC_RESET);
+	if (ret) err(1, "KVM_CPC_RESET");
 
-	// arg = true;
-	// ret = ioctl(kvm_dev, KVM_CPC_MEASURE_BASELINE, &arg);
-	// if (ret) err(1, "ioctl MEASURE_BASELINE");
+	arg = true;
+	ret = ioctl(kvm_dev, KVM_CPC_CALC_BASELINE, &arg);
+	if (ret) err(1, "KVM_CPC_CALC_BASELINE");
 
-	// arg = KVM_PAGE_TRACK_ACCESS;
-	// ret = ioctl(kvm_dev, KVM_CPC_TRACK_ALL, &arg);
-	// if (ret) err(1, "ioctl TRACK_ALL");
+	arg = CPC_TRACK_STEPS;
+	ret = ioctl(kvm_dev, KVM_CPC_TRACK_MODE, &arg);
+	if (ret) err(1, "KVM_CPC_RESET");
 
-	// arg = CPC_TRACK_DATA_ACCESS;
-	// ret = ioctl(kvm_dev, KVM_CPC_TRACK_MODE, &arg);
-	// if (ret) err(1, "ioctl TRACK_MODE");
+	eventcnt = 0;
+	while (eventcnt < 50) {
+		eventcnt += monitor(true);
+	}
 
-	// faultcnt = 0;
-	// while (faultcnt < 100) {
-	// 	if (monitor(true)) break;
-	// }
+	ret = ioctl(kvm_dev, KVM_CPC_VM_REQ_PAUSE);
+	if (ret) err(1, "KVM_CPC_VM_REQ_PAUSE");
 
-	// do {
-	// 	ret = ioctl(kvm_dev, KVM_CPC_POLL_EVENT, &event);
-	// 	if (ret && errno != EAGAIN)
-	// 		err(1, "ioctl POLL_EVENT");
-	// } while (ret && errno == EAGAIN);
+	while (1) {
+		ret = ioctl(kvm_dev, KVM_CPC_POLL_EVENT, &event);
+		if (ret && errno == EAGAIN) continue;
+		if (ret) err(1, "KVM_CPC_POLL_EVENT");
 
-	// arg = KVM_PAGE_TRACK_ACCESS;
-	// ret = ioctl(kvm_dev, KVM_CPC_UNTRACK_ALL, &arg);
-	// if (ret) err(1, "ioctl UNTRACK_ALL");
+		if (event.type == CPC_EVENT_PAUSE) break;
 
-	arg = CPC_TRACK_EXEC;
-	ret = ioctl(kvm_dev, KVM_CPC_TRACK_MODE, &arg);
-	if (ret) err(1, "ioctl TRACK_MODE");
+		ret = ioctl(kvm_dev, KVM_CPC_ACK_EVENT, &event.id);
+		if (ret) err(1, "KVM_CPC_ACK_EVENT");
+	}
 
-	arg = KVM_PAGE_TRACK_EXEC;
-	ret = ioctl(kvm_dev, KVM_CPC_TRACK_ALL, &arg);
-	if (ret) err(1, "ioctl TRACK_ALL");
+	arg = false;
+	ret = ioctl(kvm_dev, KVM_CPC_CALC_BASELINE, &arg);
+	if (ret) err(1, "KVM_CPC_CALC_BASELINE");
 
-	// arg = false;
-	// ret = ioctl(kvm_dev, KVM_CPC_MEASURE_BASELINE, &arg);
-	// if (ret) err(1, "ioctl MEASURE_BASELINE");
+	arg = true;
+	ret = ioctl(kvm_dev, KVM_CPC_APPLY_BASELINE, &arg);
+	if (ret) err(1, "KVM_CPC_APPLY_BASELINE");
 
-	// ret = ioctl(kvm_dev, KVM_CPC_READ_BASELINE, baseline);
-	// if (ret) err(1, "ioctl READ_BASELINE");
+	ret = ioctl(kvm_dev, KVM_CPC_READ_BASELINE, baseline);
+	if (ret) err(1, "KVM_CPC_READ_BASELINE");
 
-	// printf("\n>>> BASELINE:\n");
-	// print_counts(baseline);
-	// printf("\n");
-	// print_counts_raw(baseline);
-	// printf("\n");
+	printf("\nBaseline:\n");
+	print_counts(baseline);
+	printf("\n");
+	print_counts_raw(baseline);
+	printf("\n\n");
 
-	// /* Check baseline for saturated sets */
-	// for (i = 0; i < 64; i++) {
-	// 	if (baseline[i] >= 8)
-	// 		errx(1, "!!! Baseline set %i full\n", i);
-	// }
+	arg = CPC_TRACK_STEPS_SIGNALLED;
+	ret = ioctl(kvm_dev, KVM_CPC_TRACK_MODE, &arg);
+	if (ret) err(1, "KVM_CPC_RESET");
 
-	// arg = true;
-	// ret = ioctl(kvm_dev, KVM_CPC_SUB_BASELINE, &arg);
-	// if (ret) err(1, "ioctl SUB_BASELINE");
+	ret = ioctl(kvm_dev, KVM_CPC_ACK_EVENT, &event.id);
+	if (ret) err(1, "KVM_CPC_ACK_EVENT");
 
-	// ret = ioctl(kvm_dev, KVM_CPC_ACK_EVENT, &event.id);
-	// if (ret) err(1, "ioctl ACK_EVENT");
+	signal(SIGINT, reset);
 
-	faultcnt = 0;
-	while (faultcnt < 10) {
-		if (monitor(false)) break;
-	}
+	while (monitor(false) != 2);
 
-	arg = KVM_PAGE_TRACK_EXEC;
-	ret = ioctl(kvm_dev, KVM_CPC_UNTRACK_ALL, &arg);
-	if (ret) err(1, "ioctl UNTRACK_ALL");
+	ret = ioctl(kvm_dev, KVM_CPC_RESET);
+	if (ret) err(1, "KVM_CPC_RESET");
 
 	kvm_setup_deinit();
 }
diff --git a/test/qemu-eviction_guest.c b/test/qemu-eviction_guest.c
index 0cb5cab..b2586a9 100644
--- a/test/qemu-eviction_guest.c
+++ b/test/qemu-eviction_guest.c
@@ -23,8 +23,10 @@ main(int argc, const char **argv)
 
 	while (1) {
 		printf("LOOP\n");
-		CPC_DO_VMMCALL(CPC_GUEST_START_TRACK, 0);
+		CPC_DO_VMMCALL(KVM_HC_CPC_VMMCALL_SIGNAL,
+			CPC_GUEST_START_TRACK, 0);
 		*(uint8_t *)(buf + L1_LINESIZE * 15) = 1;
-		CPC_DO_VMMCALL(CPC_GUEST_STOP_TRACK, 0);
+		CPC_DO_VMMCALL(KVM_HC_CPC_VMMCALL_SIGNAL,
+			CPC_GUEST_STOP_TRACK, 0);
 	}
 }
diff --git a/test/util.c b/test/util.c
index 8b27578..11cba55 100644
--- a/test/util.c
+++ b/test/util.c
@@ -2,8 +2,10 @@
 
 #include "test/util.h"
 
-#include <pthread.h>
+#include <sys/types.h>
 #include <sys/mman.h>
+#include <dirent.h>
+#include <pthread.h>
 #include <err.h>
 #include <sched.h>
 #include <string.h>
@@ -69,6 +71,41 @@ read_stat_core(pid_t pid)
 	return cpu;
 }
 
+pid_t
+pgrep(const char *bin)
+{
+	char path[PATH_MAX];
+	char buf[PATH_MAX];
+	struct dirent *ent;
+	char *cmp;
+	FILE *f;
+	DIR *dir;
+	pid_t pid;
+
+	dir = opendir("/proc");
+	if (!dir) err(1, "opendir");
+
+	pid = 0;
+	while (!pid && (ent = readdir(dir))) {
+		snprintf(path, sizeof(path), "/proc/%s/cmdline", ent->d_name);
+		f = fopen(path, "rb");
+		if (!f) continue;
+		memset(buf, 0, sizeof(buf));
+		fread(buf, 1, sizeof(buf), f);
+		if ((cmp = strrchr(buf, '/')))
+			cmp += 1;
+		else
+			cmp = buf;
+		if (!strcmp(cmp, bin))
+			pid = atoi(ent->d_name);
+		fclose(f);
+	}
+
+	closedir(dir);
+
+	return pid;
+}
+
 void
 print_counts(uint8_t *counts)
 {
diff --git a/test/util.h b/test/util.h
index 8ad09b8..7163238 100644
--- a/test/util.h
+++ b/test/util.h
@@ -21,6 +21,7 @@ void hexdump(void *data, int len);
 bool pin_process(pid_t pid, int cpu, bool assert);
 
 int read_stat_core(pid_t pid);
+int pgrep(const char *cmd);
 
 void print_counts(uint8_t *counts);
 void print_counts_raw(uint8_t *counts);