From d27505ae4dbf2afa659df39d7498cae4b5da4454 Mon Sep 17 00:00:00 2001
From: Louis Burda <quent.burda@gmail.com>
Date: Tue, 15 Nov 2022 14:42:33 +0100
Subject: Rename files

---
 cachepc/event.c    | 131 ++++++++++++++++++++++++++++++++++++++++++++++
 cachepc/event.h    |  25 +++++++++
 cachepc/events.c   | 131 ----------------------------------------------
 cachepc/events.h   |  25 ---------
 cachepc/mmu.c      |   4 +-
 cachepc/track.c    | 149 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 cachepc/track.h    |  32 ++++++++++++
 cachepc/tracking.c | 149 -----------------------------------------------------
 cachepc/tracking.h |  32 ------------
 9 files changed, 339 insertions(+), 339 deletions(-)
 create mode 100644 cachepc/event.c
 create mode 100644 cachepc/event.h
 delete mode 100644 cachepc/events.c
 delete mode 100644 cachepc/events.h
 create mode 100644 cachepc/track.c
 create mode 100644 cachepc/track.h
 delete mode 100644 cachepc/tracking.c
 delete mode 100644 cachepc/tracking.h

diff --git a/cachepc/event.c b/cachepc/event.c
new file mode 100644
index 0000000..b06e0c0
--- /dev/null
+++ b/cachepc/event.c
@@ -0,0 +1,131 @@
+#include "events.h"
+#include "tracking.h"
+#include "cachepc.h"
+#include "uapi.h"
+
+#include <linux/kvm.h>
+#include <linux/timekeeping.h>
+#include <linux/uaccess.h>
+#include <linux/types.h>
+#include <linux/vmalloc.h>
+#include <linux/printk.h>
+#include <linux/ratelimit.h>
+
+#define ARRLEN(x) (sizeof(x)/sizeof((x)[0]))
+
+void
+cachepc_events_reset(void)
+{
+	write_lock(&cachepc_event_lock);
+	cachepc_events_init = true;
+	cachepc_last_event_sent = 1;
+	cachepc_last_event_acked = 1;
+	cachepc_event_avail = false;
+	write_unlock(&cachepc_event_lock);
+}
+
+int
+cachepc_send_tracking_event(uint64_t inst_fault_gfn, uint32_t inst_fault_err,
+	uint64_t data_fault_gfn, uint32_t data_fault_err)
+{
+	struct cpc_track_event event;
+	ktime_t deadline;
+
+	read_lock(&cachepc_event_lock);
+	if (!cachepc_events_init) {
+		pr_warn("CachePC: events ctx not initialized!\n");
+		read_unlock(&cachepc_event_lock);
+		return 1;
+	}
+	read_unlock(&cachepc_event_lock);
+
+	write_lock(&cachepc_event_lock);
+	 if (cachepc_last_event_sent != cachepc_last_event_acked) {
+		pr_warn("CachePC: event IDs out of sync\n");
+		write_unlock(&cachepc_event_lock);
+		return 1;
+	} else {
+		cachepc_last_event_sent++;
+	}
+	event.id = cachepc_last_event_sent;
+	event.inst_fault_gfn = inst_fault_gfn;
+	event.inst_fault_err = inst_fault_err;
+	event.data_fault_avail = (data_fault_err != 0);
+	event.data_fault_gfn = data_fault_gfn;
+	event.data_fault_err = data_fault_err;
+	event.timestamp_ns = ktime_get_real_ns();
+	event.retinst = cachepc_retinst;
+
+	cachepc_event_avail = true;
+	cachepc_event = event;
+	write_unlock(&cachepc_event_lock);
+
+	/* wait for ack with timeout */
+	deadline = ktime_get_ns() + 2000000000ULL; /* 2s in ns */
+	while (!cachepc_event_is_done(cachepc_event.id)) {
+		if (ktime_get_ns() > deadline) {
+			pr_warn("CachePC: Timeout waiting for ack of event %llu\n",
+				cachepc_event.id);
+			return 3;
+		}
+	}
+
+	return 0;
+}
+
+bool
+cachepc_event_is_done(uint64_t id)
+{
+	bool done;
+
+	read_lock(&cachepc_event_lock);
+	done = cachepc_last_event_acked >= id;
+	read_unlock(&cachepc_event_lock);
+
+	return done;
+}
+
+int
+cachepc_handle_poll_event_ioctl(struct cpc_track_event __user *event)
+{
+	int err;
+
+	read_lock(&cachepc_event_lock);
+	if (!cachepc_event_avail) {
+		read_unlock(&cachepc_event_lock);
+		return -EAGAIN;
+	}
+	read_unlock(&cachepc_event_lock);
+
+	write_lock(&cachepc_event_lock);
+	if (cachepc_event_avail) {
+		err = copy_to_user(event, &cachepc_event,
+			sizeof(struct cpc_track_event));
+		cachepc_event_avail = false;
+	} else {
+		err = -EAGAIN;
+	}
+	write_unlock(&cachepc_event_lock);
+
+	return err;
+}
+
+int
+cachepc_handle_ack_event_ioctl(uint64_t eventid)
+{
+	int err;
+
+	write_lock(&cachepc_event_lock);
+	if (eventid == cachepc_last_event_sent) {
+		err = 0;
+		cachepc_last_event_acked = cachepc_last_event_sent;
+	} else {
+		err = 1;
+		pr_warn("CachePC: Acked event does not match sent: %llu %llu\n",
+			cachepc_last_event_sent, eventid);
+	}
+	write_unlock(&cachepc_event_lock);
+
+	return err;
+}
+
diff --git a/cachepc/event.h b/cachepc/event.h
new file mode 100644
index 0000000..646723e
--- /dev/null
+++ b/cachepc/event.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "uapi.h"
+
+#include <linux/kvm.h>
+#include <linux/kvm_host.h>
+#include <linux/types.h>
+
+extern uint64_t cachepc_last_event_sent;
+extern uint64_t cachepc_last_event_acked;
+extern rwlock_t cachepc_event_lock;
+
+extern struct cpc_track_event cachepc_event;
+extern bool cachepc_event_avail;
+
+extern bool cachepc_events_init;
+
+void cachepc_events_reset(void);
+
+int cachepc_send_tracking_event(uint64_t inst_fault_gfn, uint32_t inst_fault_err,
+	uint64_t data_fault_gfn, uint32_t data_fault_err);
+bool cachepc_event_is_done(uint64_t id);
+
+int cachepc_handle_poll_event_ioctl(struct cpc_track_event *userpace_mem);
+int cachepc_handle_ack_event_ioctl(uint64_t eventid);
diff --git a/cachepc/events.c b/cachepc/events.c
deleted file mode 100644
index b06e0c0..0000000
--- a/cachepc/events.c
+++ /dev/null
@@ -1,131 +0,0 @@
-#include "events.h"
-#include "tracking.h"
-#include "cachepc.h"
-#include "uapi.h"
-
-#include <linux/kvm.h>
-#include <linux/timekeeping.h>
-#include <linux/uaccess.h>
-#include <linux/types.h>
-#include <linux/vmalloc.h>
-#include <linux/printk.h>
-#include <linux/ratelimit.h>
-
-#define ARRLEN(x) (sizeof(x)/sizeof((x)[0]))
-
-void
-cachepc_events_reset(void)
-{
-	write_lock(&cachepc_event_lock);
-	cachepc_events_init = true;
-	cachepc_last_event_sent = 1;
-	cachepc_last_event_acked = 1;
-	cachepc_event_avail = false;
-	write_unlock(&cachepc_event_lock);
-}
-
-int
-cachepc_send_tracking_event(uint64_t inst_fault_gfn, uint32_t inst_fault_err,
-	uint64_t data_fault_gfn, uint32_t data_fault_err)
-{
-	struct cpc_track_event event;
-	ktime_t deadline;
-
-	read_lock(&cachepc_event_lock);
-	if (!cachepc_events_init) {
-		pr_warn("CachePC: events ctx not initialized!\n");
-		read_unlock(&cachepc_event_lock);
-		return 1;
-	}
-	read_unlock(&cachepc_event_lock);
-
-	write_lock(&cachepc_event_lock);
-	 if (cachepc_last_event_sent != cachepc_last_event_acked) {
-		pr_warn("CachePC: event IDs out of sync\n");
-		write_unlock(&cachepc_event_lock);
-		return 1;
-	} else {
-		cachepc_last_event_sent++;
-	}
-	event.id = cachepc_last_event_sent;
-	event.inst_fault_gfn = inst_fault_gfn;
-	event.inst_fault_err = inst_fault_err;
-	event.data_fault_avail = (data_fault_err != 0);
-	event.data_fault_gfn = data_fault_gfn;
-	event.data_fault_err = data_fault_err;
-	event.timestamp_ns = ktime_get_real_ns();
-	event.retinst = cachepc_retinst;
-
-	cachepc_event_avail = true;
-	cachepc_event = event;
-	write_unlock(&cachepc_event_lock);
-
-	/* wait for ack with timeout */
-	deadline = ktime_get_ns() + 2000000000ULL; /* 2s in ns */
-	while (!cachepc_event_is_done(cachepc_event.id)) {
-		if (ktime_get_ns() > deadline) {
-			pr_warn("CachePC: Timeout waiting for ack of event %llu\n",
-				cachepc_event.id);
-			return 3;
-		}
-	}
-
-	return 0;
-}
-
-bool
-cachepc_event_is_done(uint64_t id)
-{
-	bool done;
-
-	read_lock(&cachepc_event_lock);
-	done = cachepc_last_event_acked >= id;
-	read_unlock(&cachepc_event_lock);
-
-	return done;
-}
-
-int
-cachepc_handle_poll_event_ioctl(struct cpc_track_event __user *event)
-{
-	int err;
-
-	read_lock(&cachepc_event_lock);
-	if (!cachepc_event_avail) {
-		read_unlock(&cachepc_event_lock);
-		return -EAGAIN;
-	}
-	read_unlock(&cachepc_event_lock);
-
-	write_lock(&cachepc_event_lock);
-	if (cachepc_event_avail) {
-		err = copy_to_user(event, &cachepc_event,
-			sizeof(struct cpc_track_event));
-		cachepc_event_avail = false;
-	} else {
-		err = -EAGAIN;
-	}
-	write_unlock(&cachepc_event_lock);
-
-	return err;
-}
-
-int
-cachepc_handle_ack_event_ioctl(uint64_t eventid)
-{
-	int err;
-
-	write_lock(&cachepc_event_lock);
-	if (eventid == cachepc_last_event_sent) {
-		err = 0;
-		cachepc_last_event_acked = cachepc_last_event_sent;
-	} else {
-		err = 1;
-		pr_warn("CachePC: Acked event does not match sent: %llu %llu\n",
-			cachepc_last_event_sent, eventid);
-	}
-	write_unlock(&cachepc_event_lock);
-
-	return err;
-}
-
diff --git a/cachepc/events.h b/cachepc/events.h
deleted file mode 100644
index 646723e..0000000
--- a/cachepc/events.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "uapi.h"
-
-#include <linux/kvm.h>
-#include <linux/kvm_host.h>
-#include <linux/types.h>
-
-extern uint64_t cachepc_last_event_sent;
-extern uint64_t cachepc_last_event_acked;
-extern rwlock_t cachepc_event_lock;
-
-extern struct cpc_track_event cachepc_event;
-extern bool cachepc_event_avail;
-
-extern bool cachepc_events_init;
-
-void cachepc_events_reset(void);
-
-int cachepc_send_tracking_event(uint64_t inst_fault_gfn, uint32_t inst_fault_err,
-	uint64_t data_fault_gfn, uint32_t data_fault_err);
-bool cachepc_event_is_done(uint64_t id);
-
-int cachepc_handle_poll_event_ioctl(struct cpc_track_event *userpace_mem);
-int cachepc_handle_ack_event_ioctl(uint64_t eventid);
diff --git a/cachepc/mmu.c b/cachepc/mmu.c
index 695c882..fb21469 100644
--- a/cachepc/mmu.c
+++ b/cachepc/mmu.c
@@ -1,6 +1,6 @@
-#include "../cachepc/tracking.h"
 #include "../cachepc/cachepc.h"
-#include "../cachepc/events.h"
+#include "../cachepc/track.h"
+#include "../cachepc/event.h"
 
 static void
 cachepc_uspt_page_fault_handle(struct kvm_vcpu *vcpu,
diff --git a/cachepc/track.c b/cachepc/track.c
new file mode 100644
index 0000000..a6b89e3
--- /dev/null
+++ b/cachepc/track.c
@@ -0,0 +1,149 @@
+#include "tracking.h"
+#include "cachepc.h"
+
+#include "mmu/mmu_internal.h"
+#include "mmu.h"
+
+#include "irq.h"
+#include "ioapic.h"
+#include "mmu.h"
+#include "mmu/tdp_mmu.h"
+#include "x86.h"
+#include "kvm_cache_regs.h"
+#include "kvm_emulate.h"
+#include "cpuid.h"
+#include "mmu/spte.h"
+
+#include <linux/kvm_host.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/highmem.h>
+#include <linux/moduleparam.h>
+#include <linux/export.h>
+#include <linux/swap.h>
+#include <linux/hugetlb.h>
+#include <linux/compiler.h>
+#include <linux/srcu.h>
+#include <linux/slab.h>
+#include <linux/sched/signal.h>
+#include <linux/uaccess.h>
+#include <linux/hash.h>
+#include <linux/kern_levels.h>
+#include <linux/kthread.h>
+#include <linux/sev.h>
+#include <linux/mm.h>
+#include <linux/smp.h>
+#include <linux/vmalloc.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+
+#include "kvm_cache_regs.h"
+#include "svm/svm.h"
+
+struct kvm* main_vm;
+EXPORT_SYMBOL(main_vm);
+
+bool
+cachepc_track_single(struct kvm_vcpu *vcpu, gfn_t gfn,
+	enum kvm_page_track_mode mode)
+{
+	struct kvm_memory_slot *slot;
+	int idx;
+
+	idx = srcu_read_lock(&vcpu->kvm->srcu);
+
+	slot = kvm_vcpu_gfn_to_memslot(vcpu, gfn);
+	if (slot != NULL && !kvm_slot_page_track_is_active(vcpu->kvm, slot, gfn, mode)) {
+		write_lock(&vcpu->kvm->mmu_lock);
+		kvm_slot_page_track_add_page(vcpu->kvm, slot, gfn, mode);
+		write_unlock(&vcpu->kvm->mmu_lock);
+	}
+
+	srcu_read_unlock(&vcpu->kvm->srcu, idx);
+
+	if (!slot) pr_err("Sevstep: Failed to track gfn %llu\n", gfn);
+
+	return slot != NULL;
+}
+EXPORT_SYMBOL(cachepc_track_single);
+
+bool
+cachepc_untrack_single(struct kvm_vcpu *vcpu, gfn_t gfn,
+	enum kvm_page_track_mode mode)
+{
+	struct kvm_memory_slot *slot;
+	int idx;
+
+	idx = srcu_read_lock(&vcpu->kvm->srcu);
+
+	slot = kvm_vcpu_gfn_to_memslot(vcpu, gfn);
+	if (slot != NULL && kvm_slot_page_track_is_active(vcpu->kvm, slot, gfn, mode)) {
+		write_lock(&vcpu->kvm->mmu_lock);
+		kvm_slot_page_track_remove_page(vcpu->kvm, slot, gfn, mode);
+		write_unlock(&vcpu->kvm->mmu_lock);
+	}
+
+	srcu_read_unlock(&vcpu->kvm->srcu, idx);
+
+	if (!slot) pr_err("Sevstep: Failed to untrack gfn %llu\n", gfn);
+
+	return slot != NULL;
+}
+EXPORT_SYMBOL(cachepc_untrack_single);
+
+long
+cachepc_track_all(struct kvm_vcpu *vcpu, enum kvm_page_track_mode mode)
+{
+	struct kvm_memory_slot *slot;
+	struct kvm_memslots *slots;
+	long count = 0;
+	int bkt;
+	u64 gfn;
+
+	pr_warn("Sevstep: Start tracking (mode:%i)\n", mode);
+
+	slots = kvm_vcpu_memslots(vcpu);
+	kvm_for_each_memslot(slot, bkt, slots) {
+		pr_warn("Sevstep: Slot page count: %lu\n", slot->npages);
+		for (gfn = slot->base_gfn; gfn < slot->base_gfn + slot->npages; gfn++) {
+			if (!kvm_slot_page_track_is_active(vcpu->kvm, slot, gfn, mode)) {
+				write_lock(&vcpu->kvm->mmu_lock);
+				kvm_slot_page_track_add_page(vcpu->kvm, slot, gfn, mode);
+				write_unlock(&vcpu->kvm->mmu_lock);
+				count++;
+			}
+		}
+	}
+
+	return count;
+}
+EXPORT_SYMBOL(cachepc_track_all);
+
+long
+cachepc_untrack_all(struct kvm_vcpu *vcpu, enum kvm_page_track_mode mode)
+{
+	struct kvm_memory_slot *slot;
+	struct kvm_memslots *slots;
+	long count = 0;
+	int bkt;
+	u64 gfn;
+
+	pr_warn("Sevstep: Stop tracking (mode:%i)\n", mode);
+
+	slots = kvm_vcpu_memslots(vcpu);
+	kvm_for_each_memslot(slot, bkt, slots) {
+		for (gfn = slot->base_gfn; gfn < slot->base_gfn + slot->npages; gfn++) {
+			if (kvm_slot_page_track_is_active(vcpu->kvm, slot, gfn, mode)) {
+				write_lock(&vcpu->kvm->mmu_lock);
+				kvm_slot_page_track_remove_page(vcpu->kvm, slot, gfn, mode);
+				write_unlock(&vcpu->kvm->mmu_lock);
+				count++;
+			}
+		}
+	}
+
+	return count;
+}
+EXPORT_SYMBOL(cachepc_untrack_all);
+
diff --git a/cachepc/track.h b/cachepc/track.h
new file mode 100644
index 0000000..d38a205
--- /dev/null
+++ b/cachepc/track.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <linux/types.h>
+#include <linux/spinlock_types.h>
+#include <asm/atomic.h>
+#include <linux/kvm_types.h>
+#include <asm/kvm_page_track.h>
+
+#include <linux/kvm_host.h>
+#include <linux/pid.h>
+#include <linux/psp-sev.h>
+
+extern struct kvm* main_vm;
+
+/* defined in mmu.c as they rely on static mmu-internal functions */
+bool cachepc_spte_protect(u64 *sptep,
+	bool pt_protect, enum kvm_page_track_mode mode);
+bool cachepc_rmap_protect(struct kvm_rmap_head *rmap_head,
+	bool pt_protect, enum kvm_page_track_mode mode);
+bool cachepc_kvm_mmu_slot_gfn_protect(struct kvm *kvm, struct kvm_memory_slot *slot,
+	uint64_t gfn, int min_level, enum kvm_page_track_mode mode);
+
+bool cachepc_tdp_protect_gfn(struct kvm *kvm, struct kvm_memory_slot *slot,
+	gfn_t gfn, int min_level, int mode);
+
+bool cachepc_track_single(struct kvm_vcpu *vcpu, gfn_t gfn,
+	enum kvm_page_track_mode mode);
+bool cachepc_untrack_single(struct kvm_vcpu *vcpu, gfn_t gfn,
+	enum kvm_page_track_mode mode);
+
+long cachepc_track_all(struct kvm_vcpu *vcpu, enum kvm_page_track_mode mode);
+long cachepc_untrack_all(struct kvm_vcpu *vcpu, enum kvm_page_track_mode mode);
diff --git a/cachepc/tracking.c b/cachepc/tracking.c
deleted file mode 100644
index a6b89e3..0000000
--- a/cachepc/tracking.c
+++ /dev/null
@@ -1,149 +0,0 @@
-#include "tracking.h"
-#include "cachepc.h"
-
-#include "mmu/mmu_internal.h"
-#include "mmu.h"
-
-#include "irq.h"
-#include "ioapic.h"
-#include "mmu.h"
-#include "mmu/tdp_mmu.h"
-#include "x86.h"
-#include "kvm_cache_regs.h"
-#include "kvm_emulate.h"
-#include "cpuid.h"
-#include "mmu/spte.h"
-
-#include <linux/kvm_host.h>
-#include <linux/types.h>
-#include <linux/string.h>
-#include <linux/mm.h>
-#include <linux/highmem.h>
-#include <linux/moduleparam.h>
-#include <linux/export.h>
-#include <linux/swap.h>
-#include <linux/hugetlb.h>
-#include <linux/compiler.h>
-#include <linux/srcu.h>
-#include <linux/slab.h>
-#include <linux/sched/signal.h>
-#include <linux/uaccess.h>
-#include <linux/hash.h>
-#include <linux/kern_levels.h>
-#include <linux/kthread.h>
-#include <linux/sev.h>
-#include <linux/mm.h>
-#include <linux/smp.h>
-#include <linux/vmalloc.h>
-#include <linux/slab.h>
-#include <linux/sched.h>
-
-#include "kvm_cache_regs.h"
-#include "svm/svm.h"
-
-struct kvm* main_vm;
-EXPORT_SYMBOL(main_vm);
-
-bool
-cachepc_track_single(struct kvm_vcpu *vcpu, gfn_t gfn,
-	enum kvm_page_track_mode mode)
-{
-	struct kvm_memory_slot *slot;
-	int idx;
-
-	idx = srcu_read_lock(&vcpu->kvm->srcu);
-
-	slot = kvm_vcpu_gfn_to_memslot(vcpu, gfn);
-	if (slot != NULL && !kvm_slot_page_track_is_active(vcpu->kvm, slot, gfn, mode)) {
-		write_lock(&vcpu->kvm->mmu_lock);
-		kvm_slot_page_track_add_page(vcpu->kvm, slot, gfn, mode);
-		write_unlock(&vcpu->kvm->mmu_lock);
-	}
-
-	srcu_read_unlock(&vcpu->kvm->srcu, idx);
-
-	if (!slot) pr_err("Sevstep: Failed to track gfn %llu\n", gfn);
-
-	return slot != NULL;
-}
-EXPORT_SYMBOL(cachepc_track_single);
-
-bool
-cachepc_untrack_single(struct kvm_vcpu *vcpu, gfn_t gfn,
-	enum kvm_page_track_mode mode)
-{
-	struct kvm_memory_slot *slot;
-	int idx;
-
-	idx = srcu_read_lock(&vcpu->kvm->srcu);
-
-	slot = kvm_vcpu_gfn_to_memslot(vcpu, gfn);
-	if (slot != NULL && kvm_slot_page_track_is_active(vcpu->kvm, slot, gfn, mode)) {
-		write_lock(&vcpu->kvm->mmu_lock);
-		kvm_slot_page_track_remove_page(vcpu->kvm, slot, gfn, mode);
-		write_unlock(&vcpu->kvm->mmu_lock);
-	}
-
-	srcu_read_unlock(&vcpu->kvm->srcu, idx);
-
-	if (!slot) pr_err("Sevstep: Failed to untrack gfn %llu\n", gfn);
-
-	return slot != NULL;
-}
-EXPORT_SYMBOL(cachepc_untrack_single);
-
-long
-cachepc_track_all(struct kvm_vcpu *vcpu, enum kvm_page_track_mode mode)
-{
-	struct kvm_memory_slot *slot;
-	struct kvm_memslots *slots;
-	long count = 0;
-	int bkt;
-	u64 gfn;
-
-	pr_warn("Sevstep: Start tracking (mode:%i)\n", mode);
-
-	slots = kvm_vcpu_memslots(vcpu);
-	kvm_for_each_memslot(slot, bkt, slots) {
-		pr_warn("Sevstep: Slot page count: %lu\n", slot->npages);
-		for (gfn = slot->base_gfn; gfn < slot->base_gfn + slot->npages; gfn++) {
-			if (!kvm_slot_page_track_is_active(vcpu->kvm, slot, gfn, mode)) {
-				write_lock(&vcpu->kvm->mmu_lock);
-				kvm_slot_page_track_add_page(vcpu->kvm, slot, gfn, mode);
-				write_unlock(&vcpu->kvm->mmu_lock);
-				count++;
-			}
-		}
-	}
-
-	return count;
-}
-EXPORT_SYMBOL(cachepc_track_all);
-
-long
-cachepc_untrack_all(struct kvm_vcpu *vcpu, enum kvm_page_track_mode mode)
-{
-	struct kvm_memory_slot *slot;
-	struct kvm_memslots *slots;
-	long count = 0;
-	int bkt;
-	u64 gfn;
-
-	pr_warn("Sevstep: Stop tracking (mode:%i)\n", mode);
-
-	slots = kvm_vcpu_memslots(vcpu);
-	kvm_for_each_memslot(slot, bkt, slots) {
-		for (gfn = slot->base_gfn; gfn < slot->base_gfn + slot->npages; gfn++) {
-			if (kvm_slot_page_track_is_active(vcpu->kvm, slot, gfn, mode)) {
-				write_lock(&vcpu->kvm->mmu_lock);
-				kvm_slot_page_track_remove_page(vcpu->kvm, slot, gfn, mode);
-				write_unlock(&vcpu->kvm->mmu_lock);
-				count++;
-			}
-		}
-	}
-
-	return count;
-}
-EXPORT_SYMBOL(cachepc_untrack_all);
-
diff --git a/cachepc/tracking.h b/cachepc/tracking.h
deleted file mode 100644
index d38a205..0000000
--- a/cachepc/tracking.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#pragma once
-
-#include <linux/types.h>
-#include <linux/spinlock_types.h>
-#include <asm/atomic.h>
-#include <linux/kvm_types.h>
-#include <asm/kvm_page_track.h>
-
-#include <linux/kvm_host.h>
-#include <linux/pid.h>
-#include <linux/psp-sev.h>
-
-extern struct kvm* main_vm;
-
-/* defined in mmu.c as they rely on static mmu-internal functions */
-bool cachepc_spte_protect(u64 *sptep,
-	bool pt_protect, enum kvm_page_track_mode mode);
-bool cachepc_rmap_protect(struct kvm_rmap_head *rmap_head,
-	bool pt_protect, enum kvm_page_track_mode mode);
-bool cachepc_kvm_mmu_slot_gfn_protect(struct kvm *kvm, struct kvm_memory_slot *slot,
-	uint64_t gfn, int min_level, enum kvm_page_track_mode mode);
-
-bool cachepc_tdp_protect_gfn(struct kvm *kvm, struct kvm_memory_slot *slot,
-	gfn_t gfn, int min_level, int mode);
-
-bool cachepc_track_single(struct kvm_vcpu *vcpu, gfn_t gfn,
-	enum kvm_page_track_mode mode);
-bool cachepc_untrack_single(struct kvm_vcpu *vcpu, gfn_t gfn,
-	enum kvm_page_track_mode mode);
-
-long cachepc_track_all(struct kvm_vcpu *vcpu, enum kvm_page_track_mode mode);
-long cachepc_untrack_all(struct kvm_vcpu *vcpu, enum kvm_page_track_mode mode);
-- 
cgit v1.2.3-71-gd317