KVM: x86: Rename .read_write_emulate() to .read_write_guest()

Rename the ops and helpers to read/write guest memory to clarify that they
do exactly that, i.e. aren't generic emulation flows and don't do anything
related to emulated MMIO.

Opportunistically add comments to explain the flow, e.g. it's not exactly
obvious that KVM deliberately treats "failed" accesses to guest memory as
emulated MMIO.

No functional change intended.

Tested-by: Tom Lendacky <thomas.lendacky@gmail.com>
Tested-by: Rick Edgecombe <rick.p.edgecombe@intel.com>
Link: https://patch.msgid.link/20260225012049.920665-13-seanjc@google.com
Signed-off-by: Sean Christopherson <seanjc@google.com>

diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
index 0195b77710e6a546dd7f29183dc97f05be8f43bd..cbd377bf71baf27c38d0c02eed791b9243ff0fc5 100644 (file)
--- a/arch/x86/kvm/x86.c
+++ b/arch/x86/kvm/x86.c
@@ -8102,21 +8102,21 @@ static int vcpu_mmio_gva_to_gpa(struct kvm_vcpu *vcpu, unsigned long gva,
 }
 
 struct read_write_emulator_ops {
-       int (*read_write_emulate)(struct kvm_vcpu *vcpu, gpa_t gpa,
-                                 void *val, int bytes);
+       int (*read_write_guest)(struct kvm_vcpu *vcpu, gpa_t gpa,
+                               void *val, int bytes);
        int (*read_write_mmio)(struct kvm_vcpu *vcpu, gpa_t gpa,
                               int bytes, void *val);
        bool write;
 };
 
-static int read_emulate(struct kvm_vcpu *vcpu, gpa_t gpa,
-                       void *val, int bytes)
+static int emulator_read_guest(struct kvm_vcpu *vcpu, gpa_t gpa,
+                              void *val, int bytes)
 {
        return !kvm_vcpu_read_guest(vcpu, gpa, val, bytes);
 }
 
-static int write_emulate(struct kvm_vcpu *vcpu, gpa_t gpa,
-                        void *val, int bytes)
+static int emulator_write_guest(struct kvm_vcpu *vcpu, gpa_t gpa,
+                               void *val, int bytes)
 {
        int ret;
 
@@ -8156,11 +8156,22 @@ static int emulator_read_write_onepage(unsigned long addr, void *val,
                        return X86EMUL_PROPAGATE_FAULT;
        }
 
-       if (!ret && ops->read_write_emulate(vcpu, gpa, val, bytes))
+       /*
+        * If the memory is not _known_ to be emulated MMIO, attempt to access
+        * guest memory.  If accessing guest memory fails, e.g. because there's
+        * no memslot, then handle the access as MMIO.  Note, treating the
+        * access as emulated MMIO is technically wrong if there is a memslot,
+        * i.e. if accessing host user memory failed, but this has been KVM's
+        * historical ABI for decades.
+        */
+       if (!ret && ops->read_write_guest(vcpu, gpa, val, bytes))
                return X86EMUL_CONTINUE;
 
        /*
-        * Is this MMIO handled locally?
+        * Attempt to handle emulated MMIO within the kernel, e.g. for accesses
+        * to an in-kernel local or I/O APIC, or to an ioeventfd range attached
+        * to MMIO bus.  If the access isn't fully resolved, insert an MMIO
+        * fragment with the relevant details.
         */
        handled = ops->read_write_mmio(vcpu, gpa, bytes, val);
        if (handled == bytes)
@@ -8181,6 +8192,13 @@ static int emulator_read_write_onepage(unsigned long addr, void *val,
                frag->data = val;
        }
        frag->len = bytes;
+
+       /*
+        * Continue emulating, even though KVM needs to (eventually) do an MMIO
+        * exit to userspace.  If the access splits multiple pages, then KVM
+        * needs to exit to userspace only after emulating both parts of the
+        * access.
+        */
        return X86EMUL_CONTINUE;
 }
 
@@ -8278,7 +8296,7 @@ static int emulator_read_emulated(struct x86_emulate_ctxt *ctxt,
                                  struct x86_exception *exception)
 {
        static const struct read_write_emulator_ops ops = {
-               .read_write_emulate = read_emulate,
+               .read_write_guest = emulator_read_guest,
                .read_write_mmio = vcpu_mmio_read,
                .write = false,
        };
@@ -8293,7 +8311,7 @@ static int emulator_write_emulated(struct x86_emulate_ctxt *ctxt,
                            struct x86_exception *exception)
 {
        static const struct read_write_emulator_ops ops = {
-               .read_write_emulate = write_emulate,
+               .read_write_guest = emulator_write_guest,
                .read_write_mmio = vcpu_mmio_write,
                .write = true,
        };