[RFC PATCH 14/18] KVM: Add asynchronous userfaults, KVM_READ_USERFAULT

James Houghton
2024-07-10T23:47:13Z

It is possible that KVM wants to access a userfault-enabled GFN in a
path where it is difficult to return out to userspace with the fault
information. For these cases, add a mechanism for KVM to wait for a GFN
to not be userfault-enabled.

The mechanism introduced in this patch uses an eventfd to signal that a
userfault is ready to be read. Userspace then reads the userfault with
KVM_READ_USERFAULT. The fault itself is stored in a list, and KVM will
busy-wait for the gfn to not be userfault-enabled.

The implementation of this mechanism is certain to change before KVM
Userfault could possibly be merged. Really the main concerns are whether
or not this kind of asynchronous userfault system is required and if the
UAPI for reading faults works.

Signed-off-by: James Houghton <jthoughton@google.com>
---
include/linux/kvm_host.h | 7 +++
include/uapi/linux/kvm.h | 7 +++
virt/kvm/kvm_main.c | 92 +++++++++++++++++++++++++++++++++++++++-
3 files changed, 104 insertions(+), 2 deletions(-)

diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index dc12d0a5498b..3b9780d85877 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -734,8 +734,15 @@ struct kvm_memslots {
int node_idx;
};

+struct kvm_userfault_list_entry {
+ struct list_head list;
+ gfn_t gfn;
+};
+
struct kvm_userfault_ctx {
struct eventfd_ctx *ev_fd;
+ spinlock_t list_lock;
+ struct list_head gfn_list;
};

struct kvm {
diff --git a/include/uapi/linux/kvm.h b/include/uapi/linux/kvm.h
index 6aa99b4587c6..8cd8e08f11e1 100644
--- a/include/uapi/linux/kvm.h
+++ b/include/uapi/linux/kvm.h
@@ -1554,4 +1554,11 @@ struct kvm_create_guest_memfd {
#define KVM_USERFAULT_ENABLE (1ULL << 0)
#define KVM_USERFAULT_DISABLE (1ULL << 1)

+struct kvm_fault {
+ __u64 address;
+ /* TODO: reserved fields */
+};
+
+#define KVM_READ_USERFAULT _IOR(KVMIO, 0xd5, struct kvm_fault)
+
#endif /* __LINUX_KVM_H */
diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c
index 4ac018cac704..d2ca16ddcaa1 100644
--- a/virt/kvm/kvm_main.c
+++ b/virt/kvm/kvm_main.c
@@ -2678,6 +2678,43 @@ static bool memslot_is_readonly(const struct kvm_memory_slot *slot)
return slot->flags & KVM_MEM_READONLY;
}

+static int read_userfault(struct kvm_userfault_ctx __rcu *ctx, gfn_t *gfn)
+{
+ struct kvm_userfault_list_entry *entry;
+
+ spin_lock(&ctx->list_lock);
+
+ entry = list_first_entry_or_null(&ctx->gfn_list,
+ struct kvm_userfault_list_entry,
+ list);
+
+ list_del(&entry->list);
+
+ spin_unlock(&ctx->list_lock);
+
+ if (!entry)
+ return -ENOENT;
+
+ *gfn = entry->gfn;
+ return 0;
+}
+
+static void signal_userfault(struct kvm *kvm, gfn_t gfn)
+{
+ struct kvm_userfault_ctx __rcu *ctx =
+ srcu_dereference(kvm->userfault_ctx, &kvm->srcu);
+ struct kvm_userfault_list_entry entry;
+
+ entry.gfn = gfn;
+ INIT_LIST_HEAD(&entry.list);
+
+ spin_lock(&ctx->list_lock);
+ list_add(&entry.list, &ctx->gfn_list);
+ spin_unlock(&ctx->list_lock);
+
+ eventfd_signal(ctx->ev_fd);
+}
+
static unsigned long __gfn_to_hva_many(const struct kvm_memory_slot *slot, gfn_t gfn,
gfn_t *nr_pages, bool write, bool atomic)
{
@@ -2687,8 +2724,14 @@ static unsigned long __gfn_to_hva_many(const struct kvm_memory_slot *slot, gfn_t
if (memslot_is_readonly(slot) && write)
return KVM_HVA_ERR_RO_BAD;

- if (gfn_has_userfault(slot->kvm, gfn))
- return KVM_HVA_ERR_USERFAULT;
+ if (gfn_has_userfault(slot->kvm, gfn)) {
+ if (atomic)
+ return KVM_HVA_ERR_USERFAULT;
+ signal_userfault(slot->kvm, gfn);
+ while (gfn_has_userfault(slot->kvm, gfn))
+ /* TODO: don't busy-wait */
+ cpu_relax();
+ }

if (nr_pages)
*nr_pages = slot->npages - (gfn - slot->base_gfn);
@@ -5009,6 +5052,10 @@ static int kvm_enable_userfault(struct kvm *kvm, int event_fd)
}

ret = 0;
+
+ INIT_LIST_HEAD(&userfault_ctx->gfn_list);
+ spin_lock_init(&userfault_ctx->list_lock);
+
userfault_ctx->ev_fd = ev_fd;

rcu_assign_pointer(kvm->userfault_ctx, userfault_ctx);
@@ -5037,6 +5084,27 @@ static int kvm_vm_ioctl_enable_userfault(struct kvm *kvm, int options,
else
return kvm_disable_userfault(kvm);
}
+
+static int kvm_vm_ioctl_read_userfault(struct kvm *kvm, gfn_t *gfn)
+{
+ int ret;
+ int idx;
+ struct kvm_userfault_ctx __rcu *ctx;
+
+ idx = srcu_read_lock(&kvm->srcu);
+
+ ctx = srcu_dereference(kvm->userfault_ctx, &kvm->srcu);
+
+ ret = -ENOENT;
+ if (!ctx)
+ goto out;
+
+ ret = read_userfault(ctx, gfn);
+
+out:
+ srcu_read_unlock(&kvm->srcu, idx);
+ return ret;
+}
#endif

static int kvm_vm_ioctl_enable_cap_generic(struct kvm *kvm,
@@ -5403,6 +5471,26 @@ static long kvm_vm_ioctl(struct file *filp,
r = kvm_gmem_create(kvm, &guest_memfd);
break;
}
+#endif
+#ifdef CONFIG_KVM_USERFAULT
+ case KVM_READ_USERFAULT: {
+ struct kvm_fault fault;
+ gfn_t gfn;
+
+ r = kvm_vm_ioctl_read_userfault(kvm, &gfn);
+ if (r)
+ goto out;
+
+ fault.address = gfn;
+
+ /* TODO: if this fails, this gfn is lost. */
+ r = -EFAULT;
+ if (copy_to_user(&fault, argp, sizeof(fault)))
+ goto out;
+
+ r = 0;
+ break;
+ }
#endif
default:
r = kvm_arch_vm_ioctl(filp, ioctl, arg);
--
2.45.2.993.g49e7a77208-goog