KVM: x86 emulator: add framework for instruction intercepts

When running in guest mode, certain instructions can be intercepted by
hardware.  This also holds for nested guests running on emulated
virtualization hardware, in particular instructions emulated by kvm
itself.

This patch adds a framework for intercepting instructions.  If an
instruction is marked for interception, and if we're running in guest
mode, a callback is called to check whether an intercept is needed or
not.  The callback is called at three points in time: immediately after
beginning execution, after checking privilge exceptions, and after
checking memory exception.  This suits the different interception points
defined for different instructions and for the various virtualization
instruction sets.

In addition, a new X86EMUL_INTERCEPT is defined, which any callback or
memory access may define, allowing the more complicated intercepts to be
implemented in existing callbacks.

Signed-off-by: Avi Kivity <avi@redhat.com>
Signed-off-by: Joerg Roedel <joerg.roedel@amd.com>
Signed-off-by: Avi Kivity <avi@redhat.com>

1 files changed, 26 insertions, 0 deletions

diff --git a/arch/x86/kvm/emulate.c b/arch/x86/kvm/emulate.c
index 2b6c24e572d4..a81486790ba8 100644
--- a/arch/x86/kvm/emulate.c
+++ b/arch/x86/kvm/emulate.c
@@ -104,6 +104,7 @@
 
 struct opcode {
         u32 flags;
+        u8 intercept;
         union {
                 int (*execute)(struct x86_emulate_ctxt *ctxt);
                 struct opcode *group;
@@ -2423,10 +2424,13 @@ static int em_movdqu(struct x86_emulate_ctxt *ctxt)
 }
 
 #define D(_y) { .flags = (_y) }
+#define DI(_y, _i) { .flags = (_y), .intercept = x86_intercept_##_i }
 #define N    D(0)
 #define G(_f, _g) { .flags = ((_f) | Group), .u.group = (_g) }
 #define GD(_f, _g) { .flags = ((_f) | Group | GroupDual), .u.gdual = (_g) }
 #define I(_f, _e) { .flags = (_f), .u.execute = (_e) }
+#define II(_f, _e, _i) \
+        { .flags = (_f), .u.execute = (_e), .intercept = x86_intercept_##_i }
 #define GP(_f, _g) { .flags = ((_f) | Prefix), .u.gprefix = (_g) }
 
 #define D2bv(_f)      D((_f) | ByteOp), D(_f)
@@ -2867,6 +2871,7 @@ done_prefixes:
         }
 
         c->execute = opcode.u.execute;
+        c->intercept = opcode.intercept;
 
         /* Unrecognised? */
         if (c->d == 0 || (c->d & Undefined))
@@ -3116,12 +3121,26 @@ x86_emulate_insn(struct x86_emulate_ctxt *ctxt)
                 goto done;
         }
 
+        if (unlikely(ctxt->guest_mode) && c->intercept) {
+                rc = ops->intercept(ctxt, c->intercept,
+                                    X86_ICPT_PRE_EXCEPT);
+                if (rc != X86EMUL_CONTINUE)
+                        goto done;
+        }
+
         /* Privileged instruction can be executed only in CPL=0 */
         if ((c->d & Priv) && ops->cpl(ctxt->vcpu)) {
                 rc = emulate_gp(ctxt, 0);
                 goto done;
         }
 
+        if (unlikely(ctxt->guest_mode) && c->intercept) {
+                rc = ops->intercept(ctxt, c->intercept,
+                                    X86_ICPT_POST_EXCEPT);
+                if (rc != X86EMUL_CONTINUE)
+                        goto done;
+        }
+
         if (c->rep_prefix && (c->d & String)) {
                 /* All REP prefixes have the same first termination condition */
                 if (address_mask(c, c->regs[VCPU_REGS_RCX]) == 0) {
@@ -3160,6 +3179,13 @@ x86_emulate_insn(struct x86_emulate_ctxt *ctxt)
 
 special_insn:
 
+        if (unlikely(ctxt->guest_mode) && c->intercept) {
+                rc = ops->intercept(ctxt, c->intercept,
+                                    X86_ICPT_POST_MEMACCESS);
+                if (rc != X86EMUL_CONTINUE)
+                        goto done;
+        }
+
         if (c->execute) {
                 rc = c->execute(ctxt);
                 if (rc != X86EMUL_CONTINUE)