[PATCH v6 02/12] KVM: SVM: Change intercept_cr to generic intercepts

Babu Moger
2020-09-11T19:34:59Z

Change intercept_cr to generic intercepts in vmcb_control_area.
Use the new vmcb_set_intercept, vmcb_clr_intercept and vmcb_is_intercept
where applicable.

Signed-off-by: Babu Moger <babu.moger@amd.com>
Reviewed-by: Jim Mattson <jmattson@google.com>
---
arch/x86/include/asm/svm.h | 42 ++++++++++++++++++++++++++++++++----------
arch/x86/kvm/svm/nested.c | 26 +++++++++++++++++---------
arch/x86/kvm/svm/svm.c | 4 ++--
arch/x86/kvm/svm/svm.h | 12 ++++++------
4 files changed, 57 insertions(+), 27 deletions(-)

diff --git a/arch/x86/include/asm/svm.h b/arch/x86/include/asm/svm.h
index 8a1f5382a4ea..d4739f4eae63 100644
--- a/arch/x86/include/asm/svm.h
+++ b/arch/x86/include/asm/svm.h
@@ -4,6 +4,37 @@

#include <uapi/asm/svm.h>

+/*
+ * VMCB Control Area intercept bits starting
+ * at Byte offset 000h (Vector 0).
+ */
+
+enum vector_offset {
+ CR_VECTOR = 0,
+ MAX_VECTORS,
+};
+
+enum {
+ /* Byte offset 000h (Vector 0) */
+ INTERCEPT_CR0_READ = 0,
+ INTERCEPT_CR1_READ,
+ INTERCEPT_CR2_READ,
+ INTERCEPT_CR3_READ,
+ INTERCEPT_CR4_READ,
+ INTERCEPT_CR5_READ,
+ INTERCEPT_CR6_READ,
+ INTERCEPT_CR7_READ,
+ INTERCEPT_CR8_READ,
+ INTERCEPT_CR0_WRITE = 16,
+ INTERCEPT_CR1_WRITE,
+ INTERCEPT_CR2_WRITE,
+ INTERCEPT_CR3_WRITE,
+ INTERCEPT_CR4_WRITE,
+ INTERCEPT_CR5_WRITE,
+ INTERCEPT_CR6_WRITE,
+ INTERCEPT_CR7_WRITE,
+ INTERCEPT_CR8_WRITE,
+};

enum {
INTERCEPT_INTR,
@@ -57,7 +88,7 @@ enum {

struct __attribute__ ((__packed__)) vmcb_control_area {
- u32 intercept_cr;
+ u32 intercepts[MAX_VECTORS];
u32 intercept_dr;
u32 intercept_exceptions;
u64 intercept;
@@ -240,15 +271,6 @@ struct __attribute__ ((__packed__)) vmcb {
#define SVM_SELECTOR_READ_MASK SVM_SELECTOR_WRITE_MASK
#define SVM_SELECTOR_CODE_MASK (1 << 3)

-#define INTERCEPT_CR0_READ 0
-#define INTERCEPT_CR3_READ 3
-#define INTERCEPT_CR4_READ 4
-#define INTERCEPT_CR8_READ 8
-#define INTERCEPT_CR0_WRITE (16 + 0)
-#define INTERCEPT_CR3_WRITE (16 + 3)
-#define INTERCEPT_CR4_WRITE (16 + 4)
-#define INTERCEPT_CR8_WRITE (16 + 8)
-
#define INTERCEPT_DR0_READ 0
#define INTERCEPT_DR1_READ 1
#define INTERCEPT_DR2_READ 2
diff --git a/arch/x86/kvm/svm/nested.c b/arch/x86/kvm/svm/nested.c
index fb68467e6049..5f65b759abcb 100644
--- a/arch/x86/kvm/svm/nested.c
+++ b/arch/x86/kvm/svm/nested.c
@@ -98,6 +98,7 @@ static void nested_svm_uninit_mmu_context(struct kvm_vcpu *vcpu)
void recalc_intercepts(struct vcpu_svm *svm)
{
struct vmcb_control_area *c, *h, *g;
+ unsigned int i;

vmcb_mark_dirty(svm->vmcb, VMCB_INTERCEPTS);

@@ -110,15 +111,17 @@ void recalc_intercepts(struct vcpu_svm *svm)

svm->nested.host_intercept_exceptions = h->intercept_exceptions;

- c->intercept_cr = h->intercept_cr;
+ for (i = 0; i < MAX_VECTORS; i++)
+ c->intercepts[i] = h->intercepts[i];
+
c->intercept_dr = h->intercept_dr;
c->intercept_exceptions = h->intercept_exceptions;
c->intercept = h->intercept;

if (g->int_ctl & V_INTR_MASKING_MASK) {
/* We only want the cr8 intercept bits of L1 */
- c->intercept_cr &= ~(1U << INTERCEPT_CR8_READ);
- c->intercept_cr &= ~(1U << INTERCEPT_CR8_WRITE);
+ vmcb_clr_intercept(c, INTERCEPT_CR8_READ);
+ vmcb_clr_intercept(c, INTERCEPT_CR8_WRITE);

/*
* Once running L2 with HF_VINTR_MASK, EFLAGS.IF does not
@@ -131,7 +134,9 @@ void recalc_intercepts(struct vcpu_svm *svm)
/* We don't want to see VMMCALLs from a nested guest */
c->intercept &= ~(1ULL << INTERCEPT_VMMCALL);

- c->intercept_cr |= g->intercept_cr;
+ for (i = 0; i < MAX_VECTORS; i++)
+ c->intercepts[i] |= g->intercepts[i];
+
c->intercept_dr |= g->intercept_dr;
c->intercept_exceptions |= g->intercept_exceptions;
c->intercept |= g->intercept;
@@ -140,7 +145,11 @@ void recalc_intercepts(struct vcpu_svm *svm)
static void copy_vmcb_control_area(struct vmcb_control_area *dst,
struct vmcb_control_area *from)
{
- dst->intercept_cr = from->intercept_cr;
+ unsigned int i;
+
+ for (i = 0; i < MAX_VECTORS; i++)
+ dst->intercepts[i] = from->intercepts[i];
+
dst->intercept_dr = from->intercept_dr;
dst->intercept_exceptions = from->intercept_exceptions;
dst->intercept = from->intercept;
@@ -487,8 +496,8 @@ int nested_svm_vmrun(struct vcpu_svm *svm)
nested_vmcb->control.event_inj,
nested_vmcb->control.nested_ctl);

- trace_kvm_nested_intercepts(nested_vmcb->control.intercept_cr & 0xffff,
- nested_vmcb->control.intercept_cr >> 16,
+ trace_kvm_nested_intercepts(nested_vmcb->control.intercepts[CR_VECTOR] & 0xffff,
+ nested_vmcb->control.intercepts[CR_VECTOR] >> 16,
nested_vmcb->control.intercept_exceptions,
nested_vmcb->control.intercept);

@@ -765,8 +774,7 @@ static int nested_svm_intercept(struct vcpu_svm *svm)
vmexit = nested_svm_intercept_ioio(svm);
break;
case SVM_EXIT_READ_CR0 ... SVM_EXIT_WRITE_CR8: {
- u32 bit = 1U << (exit_code - SVM_EXIT_READ_CR0);
- if (svm->nested.ctl.intercept_cr & bit)
+ if (vmcb_is_intercept(&svm->nested.ctl, exit_code))
vmexit = NESTED_EXIT_DONE;
break;
}
diff --git a/arch/x86/kvm/svm/svm.c b/arch/x86/kvm/svm/svm.c
index 03dd7bac8034..523936b80dda 100644
--- a/arch/x86/kvm/svm/svm.c
+++ b/arch/x86/kvm/svm/svm.c
@@ -2813,8 +2813,8 @@ static void dump_vmcb(struct kvm_vcpu *vcpu)
}

pr_err("VMCB Control Area:\n");
- pr_err("%-20s%04x\n", "cr_read:", control->intercept_cr & 0xffff);
- pr_err("%-20s%04x\n", "cr_write:", control->intercept_cr >> 16);
+ pr_err("%-20s%04x\n", "cr_read:", control->intercepts[CR_VECTOR] & 0xffff);
+ pr_err("%-20s%04x\n", "cr_write:", control->intercepts[CR_VECTOR] >> 16);
pr_err("%-20s%04x\n", "dr_read:", control->intercept_dr & 0xffff);
pr_err("%-20s%04x\n", "dr_write:", control->intercept_dr >> 16);
pr_err("%-20s%08x\n", "exceptions:", control->intercept_exceptions);
diff --git a/arch/x86/kvm/svm/svm.h b/arch/x86/kvm/svm/svm.h
index 1cff7644e70b..e775c502a074 100644
--- a/arch/x86/kvm/svm/svm.h
+++ b/arch/x86/kvm/svm/svm.h
@@ -216,24 +216,24 @@ static inline struct vmcb *get_host_vmcb(struct vcpu_svm *svm)

static inline void vmcb_set_intercept(struct vmcb_control_area *control, int bit)
{
- __set_bit(bit, (unsigned long *)&control->intercept_cr);
+ __set_bit(bit, (unsigned long *)&control->intercepts);
}

static inline void vmcb_clr_intercept(struct vmcb_control_area *control, int bit)
{
- __clear_bit(bit, (unsigned long *)&control->intercept_cr);
+ __clear_bit(bit, (unsigned long *)&control->intercepts);
}

static inline bool vmcb_is_intercept(struct vmcb_control_area *control, int bit)
{
- return test_bit(bit, (unsigned long *)&control->intercept_cr);
+ return test_bit(bit, (unsigned long *)&control->intercepts);
}

static inline void set_cr_intercept(struct vcpu_svm *svm, int bit)
{
struct vmcb *vmcb = get_host_vmcb(svm);

- vmcb->control.intercept_cr |= (1U << bit);
+ vmcb_set_intercept(&vmcb->control, bit);

recalc_intercepts(svm);
}
@@ -242,7 +242,7 @@ static inline void clr_cr_intercept(struct vcpu_svm *svm, int bit)
{
struct vmcb *vmcb = get_host_vmcb(svm);

- vmcb->control.intercept_cr &= ~(1U << bit);
+ vmcb_clr_intercept(&vmcb->control, bit);

recalc_intercepts(svm);
}
@@ -251,7 +251,7 @@ static inline bool is_cr_intercept(struct vcpu_svm *svm, int bit)
{
struct vmcb *vmcb = get_host_vmcb(svm);

- return vmcb->control.intercept_cr & (1U << bit);
+ return vmcb_is_intercept(&vmcb->control, bit);
}

static inline void set_dr_intercepts(struct vcpu_svm *svm)