nestedsvm: ns_vmcb -> vvmcb

diff -r 6fc41d2ebe57 -r 980ec1b72796 xen/arch/x86/hvm/svm/nestedsvm.c
@@ -319,7 +319,7 @@ static int nsvm_vmrun_permissionmap(stru
     struct arch_svm_struct *arch_svm = &v->arch.hvm_svm;
     struct nestedsvm *svm = &vcpu_nestedsvm(v);
     struct nestedvcpu *nv = &vcpu_nestedhvm(v);
-    struct vmcb_struct *ns_vmcb = nv->nv_vvmcx;
+    struct vmcb_struct *vvmcb = nv->nv_vvmcx;
     struct vmcb_struct *host_vmcb = arch_svm->vmcb;
     unsigned long *ns_msrpm_ptr;
     unsigned int i;

@@ -330,7 +330,7 @@ static int nsvm_vmrun_permissionmap(stru
     ns_msrpm_ptr = (unsigned long *)svm->ns_cached_msrpm;
 
     ret = hvm_copy_from_guest_phys(svm->ns_cached_msrpm,
-                                   ns_vmcb->_msrpm_base_pa, MSRPM_SIZE);
+                                   vvmcb->_msrpm_base_pa, MSRPM_SIZE);
     if (ret != HVMCOPY_okay) {
         gdprintk(XENLOG_ERR, "hvm_copy_from_guest_phys msrpm %u\n", ret);
         return 1;

@@ -340,7 +340,7 @@ static int nsvm_vmrun_permissionmap(stru
      * if l1 guest intercepts io ports 0x80 and/or 0xED.
      */
     svm->ns_oiomap_pa = svm->ns_iomap_pa;
-    svm->ns_iomap_pa = ns_vmcb->_iopm_base_pa;
+    svm->ns_iomap_pa = vvmcb->_iopm_base_pa;
 
     ns_viomap = hvm_map_guest_frame_ro(svm->ns_iomap_pa >> PAGE_SHIFT);
     ASSERT(ns_viomap != NULL);

@@ -383,15 +383,15 @@ static int nsvm_vmcb_prepare4vmrun(struc
 {
     struct nestedvcpu *nv = &vcpu_nestedhvm(v);
     struct nestedsvm *svm = &vcpu_nestedsvm(v);
-    struct vmcb_struct *ns_vmcb, *n1vmcb, *n2vmcb;
+    struct vmcb_struct *vvmcb, *n1vmcb, *n2vmcb;
     bool_t vcleanbits_valid;
     int rc;
     uint64_t cr0;
 
-    ns_vmcb = nv->nv_vvmcx;
+    vvmcb = nv->nv_vvmcx;
     n1vmcb = nv->nv_n1vmcx;
     n2vmcb = nv->nv_n2vmcx;
-    ASSERT(ns_vmcb != NULL);
+    ASSERT(vvmcb != NULL);
     ASSERT(n1vmcb != NULL);
     ASSERT(n2vmcb != NULL);
 

@@ -403,15 +403,15 @@ static int nsvm_vmcb_prepare4vmrun(struc
         vcleanbits_valid = 0;
 
 #define vcleanbit_set(_name)	\
-    (vcleanbits_valid && ns_vmcb->cleanbits.fields._name)
+    (vcleanbits_valid && vvmcb->cleanbits.fields._name)
 
     /* Enable l2 guest intercepts */
     if (!vcleanbit_set(intercepts)) {
-        svm->ns_cr_intercepts = ns_vmcb->_cr_intercepts;
-        svm->ns_dr_intercepts = ns_vmcb->_dr_intercepts;
-        svm->ns_exception_intercepts = ns_vmcb->_exception_intercepts;
-        svm->ns_general1_intercepts = ns_vmcb->_general1_intercepts;
-        svm->ns_general2_intercepts = ns_vmcb->_general2_intercepts;
+        svm->ns_cr_intercepts = vvmcb->_cr_intercepts;
+        svm->ns_dr_intercepts = vvmcb->_dr_intercepts;
+        svm->ns_exception_intercepts = vvmcb->_exception_intercepts;
+        svm->ns_general1_intercepts = vvmcb->_general1_intercepts;
+        svm->ns_general2_intercepts = vvmcb->_general2_intercepts;
     }
 
     /* We could track the cleanbits of the n1vmcb from

@@ -432,25 +432,25 @@ static int nsvm_vmcb_prepare4vmrun(struc
      */
 
     n2vmcb->_cr_intercepts =
-        n1vmcb->_cr_intercepts | ns_vmcb->_cr_intercepts;
+        n1vmcb->_cr_intercepts | vvmcb->_cr_intercepts;
     n2vmcb->_dr_intercepts =
-        n1vmcb->_dr_intercepts | ns_vmcb->_dr_intercepts;
+        n1vmcb->_dr_intercepts | vvmcb->_dr_intercepts;
     n2vmcb->_exception_intercepts =
-        n1vmcb->_exception_intercepts | ns_vmcb->_exception_intercepts;
+        n1vmcb->_exception_intercepts | vvmcb->_exception_intercepts;
     n2vmcb->_general1_intercepts =
-        n1vmcb->_general1_intercepts | ns_vmcb->_general1_intercepts;
+        n1vmcb->_general1_intercepts | vvmcb->_general1_intercepts;
     n2vmcb->_general2_intercepts =
-        n1vmcb->_general2_intercepts | ns_vmcb->_general2_intercepts;
+        n1vmcb->_general2_intercepts | vvmcb->_general2_intercepts;
 
     /* Nested Pause Filter */
-    if (ns_vmcb->_general1_intercepts & GENERAL1_INTERCEPT_PAUSE)
+    if (vvmcb->_general1_intercepts & GENERAL1_INTERCEPT_PAUSE)
         n2vmcb->_pause_filter_count =
-            min(n1vmcb->_pause_filter_count, ns_vmcb->_pause_filter_count);
+            min(n1vmcb->_pause_filter_count, vvmcb->_pause_filter_count);
     else
         n2vmcb->_pause_filter_count = n1vmcb->_pause_filter_count;
 
     /* TSC offset */
-    n2vmcb->_tsc_offset = n1vmcb->_tsc_offset + ns_vmcb->_tsc_offset;
+    n2vmcb->_tsc_offset = n1vmcb->_tsc_offset + vvmcb->_tsc_offset;
 
     /* Nested IO permission bitmaps */
     rc = nsvm_vmrun_permissionmap(v, vcleanbit_set(iopm));

@@ -460,35 +460,35 @@ static int nsvm_vmcb_prepare4vmrun(struc
     /* ASID - Emulation handled in hvm_asid_handle_vmenter() */
 
     /* TLB control */
-    n2vmcb->tlb_control = n1vmcb->tlb_control | ns_vmcb->tlb_control;
+    n2vmcb->tlb_control = n1vmcb->tlb_control | vvmcb->tlb_control;
 
     /* Virtual Interrupts */
     if (!vcleanbit_set(tpr)) {
-        n2vmcb->_vintr = ns_vmcb->_vintr;
+        n2vmcb->_vintr = vvmcb->_vintr;
         n2vmcb->_vintr.fields.intr_masking = 1;
     }
 
     /* Shadow Mode */
-    n2vmcb->interrupt_shadow = ns_vmcb->interrupt_shadow;
+    n2vmcb->interrupt_shadow = vvmcb->interrupt_shadow;
 
     /* Exit codes */
-    n2vmcb->exitcode = ns_vmcb->exitcode;
-    n2vmcb->exitinfo1 = ns_vmcb->exitinfo1;
-    n2vmcb->exitinfo2 = ns_vmcb->exitinfo2;
-    n2vmcb->exitintinfo = ns_vmcb->exitintinfo;
+    n2vmcb->exitcode = vvmcb->exitcode;
+    n2vmcb->exitinfo1 = vvmcb->exitinfo1;
+    n2vmcb->exitinfo2 = vvmcb->exitinfo2;
+    n2vmcb->exitintinfo = vvmcb->exitintinfo;
 
     /* Pending Interrupts */
-    n2vmcb->eventinj = ns_vmcb->eventinj;
+    n2vmcb->eventinj = vvmcb->eventinj;
 
     /* LBR virtualization */
     if (!vcleanbit_set(lbr)) {
-        svm->ns_lbr_control = ns_vmcb->lbr_control;
+        svm->ns_lbr_control = vvmcb->lbr_control;
     }
     n2vmcb->lbr_control.bytes =
-        n1vmcb->lbr_control.bytes | ns_vmcb->lbr_control.bytes;
+        n1vmcb->lbr_control.bytes | vvmcb->lbr_control.bytes;
 
     /* NextRIP */
-    n2vmcb->nextrip = ns_vmcb->nextrip;
+    n2vmcb->nextrip = vvmcb->nextrip;
 
     /*
      * VMCB Save State Area

@@ -496,40 +496,40 @@ static int nsvm_vmcb_prepare4vmrun(struc
 
     /* Segments */
     if (!vcleanbit_set(seg)) {
-        n2vmcb->es = ns_vmcb->es;
-        n2vmcb->cs = ns_vmcb->cs;
-        n2vmcb->ss = ns_vmcb->ss;
-        n2vmcb->ds = ns_vmcb->ds;
+        n2vmcb->es = vvmcb->es;
+        n2vmcb->cs = vvmcb->cs;
+        n2vmcb->ss = vvmcb->ss;
+        n2vmcb->ds = vvmcb->ds;
         /* CPL */
-        n2vmcb->_cpl = ns_vmcb->_cpl;
+        n2vmcb->_cpl = vvmcb->_cpl;
     }
     if (!vcleanbit_set(dt)) {
-        n2vmcb->gdtr = ns_vmcb->gdtr;
-        n2vmcb->idtr = ns_vmcb->idtr;
+        n2vmcb->gdtr = vvmcb->gdtr;
+        n2vmcb->idtr = vvmcb->idtr;
     }
 
     /* EFER */
-    v->arch.hvm_vcpu.guest_efer = ns_vmcb->_efer;
-    rc = hvm_set_efer(ns_vmcb->_efer);
+    v->arch.hvm_vcpu.guest_efer = vvmcb->_efer;
+    rc = hvm_set_efer(vvmcb->_efer);
     if (rc != X86EMUL_OKAY)
         gdprintk(XENLOG_ERR, "hvm_set_efer failed, rc: %u\n", rc);
 
     /* CR4 */
-    v->arch.hvm_vcpu.guest_cr[4] = ns_vmcb->_cr4;
-    rc = hvm_set_cr4(ns_vmcb->_cr4);
+    v->arch.hvm_vcpu.guest_cr[4] = vvmcb->_cr4;
+    rc = hvm_set_cr4(vvmcb->_cr4);
     if (rc != X86EMUL_OKAY)
         gdprintk(XENLOG_ERR, "hvm_set_cr4 failed, rc: %u\n", rc);
 
     /* CR0 */
     svm->ns_cr0 = v->arch.hvm_vcpu.guest_cr[0];
-    cr0 = nestedsvm_fpu_vmentry(svm->ns_cr0, ns_vmcb, n1vmcb, n2vmcb);
-    v->arch.hvm_vcpu.guest_cr[0] = ns_vmcb->_cr0;
+    cr0 = nestedsvm_fpu_vmentry(svm->ns_cr0, vvmcb, n1vmcb, n2vmcb);
+    v->arch.hvm_vcpu.guest_cr[0] = vvmcb->_cr0;
     rc = hvm_set_cr0(cr0);
     if (rc != X86EMUL_OKAY)
         gdprintk(XENLOG_ERR, "hvm_set_cr0 failed, rc: %u\n", rc);
 
     /* CR2 */
-    v->arch.hvm_vcpu.guest_cr[2] = ns_vmcb->_cr2;
+    v->arch.hvm_vcpu.guest_cr[2] = vvmcb->_cr2;
     hvm_update_guest_cr(v, 2);
 
     /* Nested paging mode */

@@ -537,10 +537,10 @@ static int nsvm_vmcb_prepare4vmrun(struc
         /* host nested paging + guest nested paging. */
         n2vmcb->_np_enable = 1;
 
-        nestedsvm_vmcb_set_nestedp2m(v, ns_vmcb, n2vmcb);
+        nestedsvm_vmcb_set_nestedp2m(v, vvmcb, n2vmcb);
 
         /* hvm_set_cr3() below sets v->arch.hvm_vcpu.guest_cr[3] for us. */
-        rc = hvm_set_cr3(ns_vmcb->_cr3);
+        rc = hvm_set_cr3(vvmcb->_cr3);
         if (rc != X86EMUL_OKAY)
             gdprintk(XENLOG_ERR, "hvm_set_cr3 failed, rc: %u\n", rc);
     } else if (paging_mode_hap(v->domain)) {

@@ -552,7 +552,7 @@ static int nsvm_vmcb_prepare4vmrun(struc
          * we assume it intercepts page faults.
          */
         /* hvm_set_cr3() below sets v->arch.hvm_vcpu.guest_cr[3] for us. */
-        rc = hvm_set_cr3(ns_vmcb->_cr3);
+        rc = hvm_set_cr3(vvmcb->_cr3);
         if (rc != X86EMUL_OKAY)
             gdprintk(XENLOG_ERR, "hvm_set_cr3 failed, rc: %u\n", rc);
     } else {

@@ -567,21 +567,21 @@ static int nsvm_vmcb_prepare4vmrun(struc
 
     /* DRn */
     if (!vcleanbit_set(dr)) {
-        n2vmcb->_dr7 = ns_vmcb->_dr7;
-        n2vmcb->_dr6 = ns_vmcb->_dr6;
+        n2vmcb->_dr7 = vvmcb->_dr7;
+        n2vmcb->_dr6 = vvmcb->_dr6;
     }
 
     /* RFLAGS */
-    n2vmcb->rflags = ns_vmcb->rflags;
+    n2vmcb->rflags = vvmcb->rflags;
 
     /* RIP */
-    n2vmcb->rip = ns_vmcb->rip;
+    n2vmcb->rip = vvmcb->rip;
 
     /* RSP */
-    n2vmcb->rsp = ns_vmcb->rsp;
+    n2vmcb->rsp = vvmcb->rsp;
 
     /* RAX */
-    n2vmcb->rax = ns_vmcb->rax;
+    n2vmcb->rax = vvmcb->rax;
 
     /* Keep the host values of the fs, gs, ldtr, tr, kerngsbase,
      * star, lstar, cstar, sfmask, sysenter_cs, sysenter_esp,

@@ -589,31 +589,31 @@ static int nsvm_vmcb_prepare4vmrun(struc
      */
 
     /* Page tables */
-    n2vmcb->pdpe0 = ns_vmcb->pdpe0;
-    n2vmcb->pdpe1 = ns_vmcb->pdpe1;
-    n2vmcb->pdpe2 = ns_vmcb->pdpe2;
-    n2vmcb->pdpe3 = ns_vmcb->pdpe3;
+    n2vmcb->pdpe0 = vvmcb->pdpe0;
+    n2vmcb->pdpe1 = vvmcb->pdpe1;
+    n2vmcb->pdpe2 = vvmcb->pdpe2;
+    n2vmcb->pdpe3 = vvmcb->pdpe3;
 
     /* PAT */
     if (!vcleanbit_set(np)) {
-        n2vmcb->_g_pat = ns_vmcb->_g_pat;
+        n2vmcb->_g_pat = vvmcb->_g_pat;
     }
 
     if (!vcleanbit_set(lbr)) {
         /* Debug Control MSR */
-        n2vmcb->_debugctlmsr = ns_vmcb->_debugctlmsr;
+        n2vmcb->_debugctlmsr = vvmcb->_debugctlmsr;
 
         /* LBR MSRs */
-        n2vmcb->_lastbranchfromip = ns_vmcb->_lastbranchfromip;
-        n2vmcb->_lastbranchtoip = ns_vmcb->_lastbranchtoip;
-        n2vmcb->_lastintfromip = ns_vmcb->_lastintfromip;
-        n2vmcb->_lastinttoip = ns_vmcb->_lastinttoip;
+        n2vmcb->_lastbranchfromip = vvmcb->_lastbranchfromip;
+        n2vmcb->_lastbranchtoip = vvmcb->_lastbranchtoip;
+        n2vmcb->_lastintfromip = vvmcb->_lastintfromip;
+        n2vmcb->_lastinttoip = vvmcb->_lastinttoip;
     }
 
     /* Cleanbits */
     n2vmcb->cleanbits.bytes = 0;
 
-    rc = svm_vmcb_isvalid(__func__, ns_vmcb, 1);
+    rc = svm_vmcb_isvalid(__func__, vvmcb, 1);
     if (rc) {
         gdprintk(XENLOG_ERR, "virtual vmcb invalid\n");
         return rc;

@@ -626,10 +626,10 @@ static int nsvm_vmcb_prepare4vmrun(struc
     }
 
     /* Switch guest registers to l2 guest */
-    regs->eax = ns_vmcb->rax;
-    regs->eip = ns_vmcb->rip;
-    regs->esp = ns_vmcb->rsp;
-    regs->eflags = ns_vmcb->rflags;
+    regs->eax = vvmcb->rax;
+    regs->eip = vvmcb->rip;
+    regs->esp = vvmcb->rsp;
+    regs->eflags = vvmcb->rflags;
 
 #undef vcleanbit_set
     return 0;

@@ -642,33 +642,33 @@ nsvm_vcpu_vmentry(struct vcpu *v, struct
     int ret;
     struct nestedvcpu *nv = &vcpu_nestedhvm(v);
     struct nestedsvm *svm = &vcpu_nestedsvm(v);
-    struct vmcb_struct *ns_vmcb;
+    struct vmcb_struct *vvmcb;
 
-    ns_vmcb = nv->nv_vvmcx;
-    ASSERT(ns_vmcb != NULL);
+    vvmcb = nv->nv_vvmcx;
+    ASSERT(vvmcb != NULL);
     ASSERT(nv->nv_n2vmcx != NULL);
     ASSERT(nv->nv_n2vmcx_pa != VMCX_EADDR);
 
     /* Save values for later use. Needed for Nested-on-Nested and
      * Shadow-on-Shadow paging.
      */
-    svm->ns_vmcb_guestcr3 = ns_vmcb->_cr3;
-    svm->ns_vmcb_hostcr3 = ns_vmcb->_h_cr3;
+    svm->ns_vmcb_guestcr3 = vvmcb->_cr3;
+    svm->ns_vmcb_hostcr3 = vvmcb->_h_cr3;
 
-    nv->nv_flushp2m = ns_vmcb->tlb_control;
-    if ( svm->ns_guest_asid != ns_vmcb->_guest_asid )
+    nv->nv_flushp2m = vvmcb->tlb_control;
+    if ( svm->ns_guest_asid != vvmcb->_guest_asid )
     {
         nv->nv_flushp2m = 1;
         hvm_asid_flush_vcpu_asid(&vcpu_nestedhvm(v).nv_n2asid);
-        svm->ns_guest_asid = ns_vmcb->_guest_asid;
+        svm->ns_guest_asid = vvmcb->_guest_asid;
     }
 
     /* nested paging for the guest */
-    svm->ns_hap_enabled = (ns_vmcb->_np_enable) ? 1 : 0;
+    svm->ns_hap_enabled = (vvmcb->_np_enable) ? 1 : 0;
 
     /* Remember the V_INTR_MASK in hostflags */
     svm->ns_hostflags.fields.vintrmask =
-        (ns_vmcb->_vintr.fields.intr_masking) ? 1 : 0;
+        (vvmcb->_vintr.fields.intr_masking) ? 1 : 0;
 
     /* Save l1 guest state (= host state) */
     ret = nsvm_vcpu_hostsave(v, inst_len);

@@ -735,31 +735,31 @@ nsvm_vcpu_vmexit_inject(struct vcpu *v, 
 {
     struct nestedvcpu *nv = &vcpu_nestedhvm(v);
     struct nestedsvm *svm = &vcpu_nestedsvm(v);
-    struct vmcb_struct *ns_vmcb;
+    struct vmcb_struct *vvmcb;
 
     ASSERT(svm->ns_gif == 0);
-    ns_vmcb = nv->nv_vvmcx;
+    vvmcb = nv->nv_vvmcx;
 
     if (nv->nv_vmexit_pending) {
 
         switch (exitcode) {
         case VMEXIT_INTR:
-            if ( unlikely(ns_vmcb->eventinj.fields.v)
+            if ( unlikely(vvmcb->eventinj.fields.v)
                 && nv->nv_vmentry_pending
-                && hvm_event_needs_reinjection(ns_vmcb->eventinj.fields.type,
-                    ns_vmcb->eventinj.fields.vector) )
+                && hvm_event_needs_reinjection(vvmcb->eventinj.fields.type,
+                    vvmcb->eventinj.fields.vector) )
             {
-                ns_vmcb->exitintinfo.bytes = ns_vmcb->eventinj.bytes;
+                vvmcb->exitintinfo.bytes = vvmcb->eventinj.bytes;
             }
             break;
         case VMEXIT_EXCEPTION_PF:
-            ns_vmcb->_cr2 = ns_vmcb->exitinfo2;
+            vvmcb->_cr2 = vvmcb->exitinfo2;
             /* fall through */
         case VMEXIT_NPF:
             /* PF error code */
-            ns_vmcb->exitinfo1 = svm->ns_vmexit.exitinfo1;
+            vvmcb->exitinfo1 = svm->ns_vmexit.exitinfo1;
             /* fault address */
-            ns_vmcb->exitinfo2 = svm->ns_vmexit.exitinfo2;
+            vvmcb->exitinfo2 = svm->ns_vmexit.exitinfo2;
             break;
         case VMEXIT_EXCEPTION_NP:
         case VMEXIT_EXCEPTION_SS:

@@ -767,15 +767,15 @@ nsvm_vcpu_vmexit_inject(struct vcpu *v, 
         case VMEXIT_EXCEPTION_15:
         case VMEXIT_EXCEPTION_MF:
         case VMEXIT_EXCEPTION_AC:
-            ns_vmcb->exitinfo1 = svm->ns_vmexit.exitinfo1;
+            vvmcb->exitinfo1 = svm->ns_vmexit.exitinfo1;
             break;
         default:
             break;
         }
     }
 
-    ns_vmcb->exitcode = exitcode;
-    ns_vmcb->eventinj.bytes = 0;
+    vvmcb->exitcode = exitcode;
+    vvmcb->eventinj.bytes = 0;
     return 0;
 }
 

@@ -879,7 +879,7 @@ nsvm_vmcb_guest_intercepts_exitcode(stru
     uint64_t exit_bits;
     struct nestedvcpu *nv = &vcpu_nestedhvm(v);
     struct nestedsvm *svm = &vcpu_nestedsvm(v);
-    struct vmcb_struct *ns_vmcb = nv->nv_vvmcx;
+    struct vmcb_struct *vvmcb = nv->nv_vvmcx;
     enum nestedhvm_vmexits vmexits;
 
     switch (exitcode) {

@@ -932,18 +932,18 @@ nsvm_vmcb_guest_intercepts_exitcode(stru
         ASSERT(regs != NULL);
         nestedsvm_vmcb_map(v, nv->nv_vvmcxaddr);
         ASSERT(nv->nv_vvmcx != NULL);
-        ns_vmcb = nv->nv_vvmcx;
+        vvmcb = nv->nv_vvmcx;
         vmexits = nsvm_vmcb_guest_intercepts_msr(svm->ns_cached_msrpm,
-            regs->ecx, ns_vmcb->exitinfo1 != 0);
+            regs->ecx, vvmcb->exitinfo1 != 0);
         if (vmexits == NESTEDHVM_VMEXIT_HOST)
             return 0;
         break;
     case VMEXIT_IOIO:
         nestedsvm_vmcb_map(v, nv->nv_vvmcxaddr);
         ASSERT(nv->nv_vvmcx != NULL);
-        ns_vmcb = nv->nv_vvmcx;
-        vmexits = nsvm_vmcb_guest_intercepts_ioio(ns_vmcb->_iopm_base_pa,
-            ns_vmcb->exitinfo1);
+        vvmcb = nv->nv_vvmcx;
+        vmexits = nsvm_vmcb_guest_intercepts_ioio(vvmcb->_iopm_base_pa,
+            vvmcb->exitinfo1);
         if (vmexits == NESTEDHVM_VMEXIT_HOST)
             return 0;
         break;

@@ -964,7 +964,7 @@ nsvm_vmcb_prepare4vmexit(struct vcpu *v)
 {
     struct nestedvcpu *nv = &vcpu_nestedhvm(v);
     struct nestedsvm *svm = &vcpu_nestedsvm(v);
-    struct vmcb_struct *ns_vmcb = nv->nv_vvmcx;
+    struct vmcb_struct *vvmcb = nv->nv_vvmcx;
     struct vmcb_struct *n2vmcb = nv->nv_n2vmcx;
 
     svm_vmsave(nv->nv_n1vmcx);

@@ -987,24 +987,24 @@ nsvm_vmcb_prepare4vmexit(struct vcpu *v)
     /* Keep it. It's maintainted by the l1 guest. */ 
 
     /* ASID */
-    /* ns_vmcb->_guest_asid = n2vmcb->_guest_asid; */
+    /* vvmcb->_guest_asid = n2vmcb->_guest_asid; */
 
     /* TLB control */
-    ns_vmcb->tlb_control = 0;
+    vvmcb->tlb_control = 0;
 
     /* Virtual Interrupts */
-    ns_vmcb->_vintr = n2vmcb->_vintr;
+    vvmcb->_vintr = n2vmcb->_vintr;
     if (!(svm->ns_hostflags.fields.vintrmask))
-        ns_vmcb->_vintr.fields.intr_masking = 0;
+        vvmcb->_vintr.fields.intr_masking = 0;
 
     /* Shadow mode */
-    ns_vmcb->interrupt_shadow = n2vmcb->interrupt_shadow;
+    vvmcb->interrupt_shadow = n2vmcb->interrupt_shadow;
 
     /* Exit codes */
-    ns_vmcb->exitcode = n2vmcb->exitcode;
-    ns_vmcb->exitinfo1 = n2vmcb->exitinfo1;
-    ns_vmcb->exitinfo2 = n2vmcb->exitinfo2;
-    ns_vmcb->exitintinfo = n2vmcb->exitintinfo;
+    vvmcb->exitcode = n2vmcb->exitcode;
+    vvmcb->exitinfo1 = n2vmcb->exitinfo1;
+    vvmcb->exitinfo2 = n2vmcb->exitinfo2;
+    vvmcb->exitintinfo = n2vmcb->exitintinfo;
 
     /* Interrupts */
     /* If we emulate a VMRUN/#VMEXIT in the same host #VMEXIT cycle we have

@@ -1018,79 +1018,79 @@ nsvm_vmcb_prepare4vmexit(struct vcpu *v)
          hvm_event_needs_reinjection(n2vmcb->eventinj.fields.type,
                                      n2vmcb->eventinj.fields.vector) )
     {
-        ns_vmcb->exitintinfo = n2vmcb->eventinj;
+        vvmcb->exitintinfo = n2vmcb->eventinj;
     }
 
-    ns_vmcb->eventinj.bytes = 0;
+    vvmcb->eventinj.bytes = 0;
 
     /* Nested paging mode */
     if (nestedhvm_paging_mode_hap(v)) {
         /* host nested paging + guest nested paging. */
-        ns_vmcb->_np_enable = n2vmcb->_np_enable;
-        ns_vmcb->_cr3 = n2vmcb->_cr3;
-        /* The vmcb->h_cr3 is the shadowed h_cr3. The original
-         * unshadowed guest h_cr3 is kept in ns_vmcb->h_cr3,
-         * hence we keep the ns_vmcb->h_cr3 value. */
+        vvmcb->_np_enable = n2vmcb->_np_enable;
+        vvmcb->_cr3 = n2vmcb->_cr3;
+        /* The n2vmcb->_h_cr3 is the shadowed _h_cr3. The original
+         * unshadowed guest _h_cr3 is kept in vvmcb->_h_cr3,
+         * hence we keep the vvmcb->_h_cr3 value. */
     } else if (paging_mode_hap(v->domain)) {
         /* host nested paging + guest shadow paging. */
-        ns_vmcb->_np_enable = 0;
+        vvmcb->_np_enable = 0;
         /* Throw h_cr3 away. Guest is not allowed to set it or
          * it can break out, otherwise (security hole!) */
-        ns_vmcb->_h_cr3 = 0x0;
+        vvmcb->_h_cr3 = 0x0;
         /* Stop intercepting #PF (already done above
          * by restoring cached intercepts). */
-        ns_vmcb->_cr3 = n2vmcb->_cr3;
+        vvmcb->_cr3 = n2vmcb->_cr3;
     } else {
         /* host shadow paging + guest shadow paging. */
-        ns_vmcb->_np_enable = 0;
-        ns_vmcb->_h_cr3 = 0x0;
+        vvmcb->_np_enable = 0;
+        vvmcb->_h_cr3 = 0x0;
         /* The vmcb->_cr3 is the shadowed cr3. The original
-         * unshadowed guest cr3 is kept in ns_vmcb->_cr3,
-         * hence we keep the ns_vmcb->_cr3 value. */
+         * unshadowed guest cr3 is kept in vvmcb->_cr3,
+         * hence we keep the vvmcb->_cr3 value. */
     }
 
     /* LBR virtualization - keep lbr control as is */
 
     /* NextRIP */
-    ns_vmcb->nextrip = n2vmcb->nextrip;
+    vvmcb->nextrip = n2vmcb->nextrip;
 
     /*
      * VMCB Save State Area
      */
 
     /* Segments */
-    ns_vmcb->es = n2vmcb->es;
-    ns_vmcb->cs = n2vmcb->cs;
-    ns_vmcb->ss = n2vmcb->ss;
-    ns_vmcb->ds = n2vmcb->ds;
-    ns_vmcb->gdtr = n2vmcb->gdtr;
-    ns_vmcb->idtr = n2vmcb->idtr;
+    vvmcb->es = n2vmcb->es;
+    vvmcb->cs = n2vmcb->cs;
+    vvmcb->ss = n2vmcb->ss;
+    vvmcb->ds = n2vmcb->ds;
+    vvmcb->gdtr = n2vmcb->gdtr;
+    vvmcb->idtr = n2vmcb->idtr;
 
     /* CPL */
-    ns_vmcb->_cpl = n2vmcb->_cpl;
+    vvmcb->_cpl = n2vmcb->_cpl;
 
     /* EFER */
-    ns_vmcb->_efer = n2vmcb->_efer;
+    vvmcb->_efer = n2vmcb->_efer;
 
     /* CRn */
-    ns_vmcb->_cr4 = n2vmcb->_cr4;
-    ns_vmcb->_cr0 = n2vmcb->_cr0;
+    vvmcb->_cr4 = n2vmcb->_cr4;
+    vvmcb->_cr0 = n2vmcb->_cr0;
 
     /* DRn */
-    ns_vmcb->_dr7 = n2vmcb->_dr7;
-    ns_vmcb->_dr6 = n2vmcb->_dr6;
+    vvmcb->_dr7 = n2vmcb->_dr7;
+    vvmcb->_dr6 = n2vmcb->_dr6;
 
     /* RFLAGS */
-    ns_vmcb->rflags = n2vmcb->rflags;
+    vvmcb->rflags = n2vmcb->rflags;
 
     /* RIP */
-    ns_vmcb->rip = n2vmcb->rip;
+    vvmcb->rip = n2vmcb->rip;
 
     /* RSP */
-    ns_vmcb->rsp = n2vmcb->rsp;
+    vvmcb->rsp = n2vmcb->rsp;
 
     /* RAX */
-    ns_vmcb->rax = n2vmcb->rax;
+    vvmcb->rax = n2vmcb->rax;
 
     /* Keep the l2 guest values of the fs, gs, ldtr, tr, kerngsbase,
      * star, lstar, cstar, sfmask, sysenter_cs, sysenter_esp,

@@ -1098,25 +1098,25 @@ nsvm_vmcb_prepare4vmexit(struct vcpu *v)
      */
 
     /* CR2 */
-    ns_vmcb->_cr2 = n2vmcb->_cr2;
+    vvmcb->_cr2 = n2vmcb->_cr2;
 
     /* Page tables */
-    ns_vmcb->pdpe0 = n2vmcb->pdpe0;
-    ns_vmcb->pdpe1 = n2vmcb->pdpe1;
-    ns_vmcb->pdpe2 = n2vmcb->pdpe2;
-    ns_vmcb->pdpe3 = n2vmcb->pdpe3;
+    vvmcb->pdpe0 = n2vmcb->pdpe0;
+    vvmcb->pdpe1 = n2vmcb->pdpe1;
+    vvmcb->pdpe2 = n2vmcb->pdpe2;
+    vvmcb->pdpe3 = n2vmcb->pdpe3;
 
     /* PAT */
-    ns_vmcb->_g_pat = n2vmcb->_g_pat;
+    vvmcb->_g_pat = n2vmcb->_g_pat;
 
     /* Debug Control MSR */
-    ns_vmcb->_debugctlmsr = n2vmcb->_debugctlmsr;
+    vvmcb->_debugctlmsr = n2vmcb->_debugctlmsr;
 
     /* LBR MSRs */
-    ns_vmcb->_lastbranchfromip = n2vmcb->_lastbranchfromip;
-    ns_vmcb->_lastbranchtoip = n2vmcb->_lastbranchtoip;
-    ns_vmcb->_lastintfromip = n2vmcb->_lastintfromip;
-    ns_vmcb->_lastinttoip = n2vmcb->_lastinttoip;
+    vvmcb->_lastbranchfromip = n2vmcb->_lastbranchfromip;
+    vvmcb->_lastbranchtoip = n2vmcb->_lastbranchtoip;
+    vvmcb->_lastintfromip = n2vmcb->_lastintfromip;
+    vvmcb->_lastinttoip = n2vmcb->_lastinttoip;
 
     return 0;
 }

diff -r 6fc41d2ebe57 -r 980ec1b72796 xen/arch/x86/hvm/svm/svm.c
@@ -1826,7 +1826,7 @@ asmlinkage void svm_vmexit_handler(struc
     if ( vcpu_guestmode ) {
         enum nestedhvm_vmexits nsret;
         struct nestedvcpu *nv = &vcpu_nestedhvm(v);
-        struct vmcb_struct *ns_vmcb = nv->nv_vvmcx;
+        struct vmcb_struct *vvmcb = nv->nv_vvmcx;
         uint64_t exitinfo1, exitinfo2;
 
         paging_update_nestedmode(v);

@@ -1835,8 +1835,8 @@ asmlinkage void svm_vmexit_handler(struc
          * nestedsvm_check_intercepts() expects to have the correct
          * exitinfo1 value there.
          */
-        exitinfo1 = ns_vmcb->exitinfo1;
-        ns_vmcb->exitinfo1 = vmcb->exitinfo1;
+        exitinfo1 = vvmcb->exitinfo1;
+        vvmcb->exitinfo1 = vmcb->exitinfo1;
         nsret = nestedsvm_check_intercepts(v, regs, exit_reason);
         switch (nsret) {
         case NESTEDHVM_VMEXIT_CONTINUE: