kvm: nVMX: Aesthetic cleanup of handle_vmread and handle_vmwrite

Apply reverse fir tree declaration order, shorten some variable names
to avoid line wrap, reformat a block comment, delete an extra blank
line, and use BIT(10) instead of (1u << 10).

Signed-off-by: Jim Mattson <jmattson@google.com>
Cc: Paolo Bonzini <pbonzini@redhat.com>
Cc: Sean Christopherson <sean.j.christopherson@intel.com>
Reviewed-by: Peter Shier <pshier@google.com>
Reviewed-by: Oliver Upton <oupton@google.com>
Reviewed-by: Jon Cargille <jcargill@google.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

diff --git a/arch/x86/kvm/vmx/nested.c b/arch/x86/kvm/vmx/nested.c
index e2fa5ae..7b01ef1 100644 (file)
--- a/arch/x86/kvm/vmx/nested.c
+++ b/arch/x86/kvm/vmx/nested.c
@@ -4751,17 +4751,17 @@ static int handle_vmresume(struct kvm_vcpu *vcpu)
 
 static int handle_vmread(struct kvm_vcpu *vcpu)
 {
-       unsigned long field;
-       u64 field_value;
-       struct vcpu_vmx *vmx = to_vmx(vcpu);
-       unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
-       u32 vmx_instruction_info = vmcs_read32(VMX_INSTRUCTION_INFO);
-       int len;
-       gva_t gva = 0;
        struct vmcs12 *vmcs12 = is_guest_mode(vcpu) ? get_shadow_vmcs12(vcpu)
                                                    : get_vmcs12(vcpu);
+       unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
+       u32 instr_info = vmcs_read32(VMX_INSTRUCTION_INFO);
+       struct vcpu_vmx *vmx = to_vmx(vcpu);
        struct x86_exception e;
+       unsigned long field;
+       u64 value;
+       gva_t gva = 0;
        short offset;
+       int len;
 
        if (!nested_vmx_check_permission(vcpu))
                return 1;
@@ -4776,7 +4776,7 @@ static int handle_vmread(struct kvm_vcpu *vcpu)
                return nested_vmx_failInvalid(vcpu);
 
        /* Decode instruction info and find the field to read */
-       field = kvm_register_readl(vcpu, (((vmx_instruction_info) >> 28) & 0xf));
+       field = kvm_register_readl(vcpu, (((instr_info) >> 28) & 0xf));
 
        offset = vmcs_field_to_offset(field);
        if (offset < 0)
@@ -4786,24 +4786,23 @@ static int handle_vmread(struct kvm_vcpu *vcpu)
        if (!is_guest_mode(vcpu) && is_vmcs12_ext_field(field))
                copy_vmcs02_to_vmcs12_rare(vcpu, vmcs12);
 
-       /* Read the field, zero-extended to a u64 field_value */
-       field_value = vmcs12_read_any(vmcs12, field, offset);
+       /* Read the field, zero-extended to a u64 value */
+       value = vmcs12_read_any(vmcs12, field, offset);
 
        /*
         * Now copy part of this value to register or memory, as requested.
         * Note that the number of bits actually copied is 32 or 64 depending
         * on the guest's mode (32 or 64 bit), not on the given field's length.
         */
-       if (vmx_instruction_info & (1u << 10)) {
-               kvm_register_writel(vcpu, (((vmx_instruction_info) >> 3) & 0xf),
-                       field_value);
+       if (instr_info & BIT(10)) {
+               kvm_register_writel(vcpu, (((instr_info) >> 3) & 0xf), value);
        } else {
                len = is_64_bit_mode(vcpu) ? 8 : 4;
                if (get_vmx_mem_address(vcpu, exit_qualification,
-                               vmx_instruction_info, true, len, &gva))
+                                       instr_info, true, len, &gva))
                        return 1;
                /* _system ok, nested_vmx_check_permission has verified cpl=0 */
-               if (kvm_write_guest_virt_system(vcpu, gva, &field_value, len, &e))
+               if (kvm_write_guest_virt_system(vcpu, gva, &value, len, &e))
                        kvm_inject_page_fault(vcpu, &e);
        }
 
@@ -4836,24 +4835,25 @@ static bool is_shadow_field_ro(unsigned long field)
 
 static int handle_vmwrite(struct kvm_vcpu *vcpu)
 {
+       struct vmcs12 *vmcs12 = is_guest_mode(vcpu) ? get_shadow_vmcs12(vcpu)
+                                                   : get_vmcs12(vcpu);
+       unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
+       u32 instr_info = vmcs_read32(VMX_INSTRUCTION_INFO);
+       struct vcpu_vmx *vmx = to_vmx(vcpu);
+       struct x86_exception e;
        unsigned long field;
-       int len;
+       short offset;
        gva_t gva;
-       struct vcpu_vmx *vmx = to_vmx(vcpu);
-       unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
-       u32 vmx_instruction_info = vmcs_read32(VMX_INSTRUCTION_INFO);
+       int len;
 
-       /* The value to write might be 32 or 64 bits, depending on L1's long
+       /*
+        * The value to write might be 32 or 64 bits, depending on L1's long
         * mode, and eventually we need to write that into a field of several
         * possible lengths. The code below first zero-extends the value to 64
-        * bit (field_value), and then copies only the appropriate number of
+        * bit (value), and then copies only the appropriate number of
         * bits into the vmcs12 field.
         */
-       u64 field_value = 0;
-       struct x86_exception e;
-       struct vmcs12 *vmcs12 = is_guest_mode(vcpu) ? get_shadow_vmcs12(vcpu)
-                                                   : get_vmcs12(vcpu);
-       short offset;
+       u64 value = 0;
 
        if (!nested_vmx_check_permission(vcpu))
                return 1;
@@ -4867,22 +4867,20 @@ static int handle_vmwrite(struct kvm_vcpu *vcpu)
             get_vmcs12(vcpu)->vmcs_link_pointer == -1ull))
                return nested_vmx_failInvalid(vcpu);
 
-       if (vmx_instruction_info & (1u << 10))
-               field_value = kvm_register_readl(vcpu,
-                       (((vmx_instruction_info) >> 3) & 0xf));
+       if (instr_info & BIT(10))
+               value = kvm_register_readl(vcpu, (((instr_info) >> 3) & 0xf));
        else {
                len = is_64_bit_mode(vcpu) ? 8 : 4;
                if (get_vmx_mem_address(vcpu, exit_qualification,
-                               vmx_instruction_info, false, len, &gva))
+                                       instr_info, false, len, &gva))
                        return 1;
-               if (kvm_read_guest_virt(vcpu, gva, &field_value, len, &e)) {
+               if (kvm_read_guest_virt(vcpu, gva, &value, len, &e)) {
                        kvm_inject_page_fault(vcpu, &e);
                        return 1;
                }
        }
 
-
-       field = kvm_register_readl(vcpu, (((vmx_instruction_info) >> 28) & 0xf));
+       field = kvm_register_readl(vcpu, (((instr_info) >> 28) & 0xf));
 
        offset = vmcs_field_to_offset(field);
        if (offset < 0)
@@ -4914,9 +4912,9 @@ static int handle_vmwrite(struct kvm_vcpu *vcpu)
         * the stripped down value, L2 sees the full value as stored by KVM).
         */
        if (field >= GUEST_ES_AR_BYTES && field <= GUEST_TR_AR_BYTES)
-               field_value &= 0x1f0ff;
+               value &= 0x1f0ff;
 
-       vmcs12_write_any(vmcs12, field, offset, field_value);
+       vmcs12_write_any(vmcs12, field, offset, value);
 
        /*
         * Do not track vmcs12 dirty-state if in guest-mode as we actually
@@ -4933,7 +4931,7 @@ static int handle_vmwrite(struct kvm_vcpu *vcpu)
                        preempt_disable();
                        vmcs_load(vmx->vmcs01.shadow_vmcs);
 
-                       __vmcs_writel(field, field_value);
+                       __vmcs_writel(field, value);
 
                        vmcs_clear(vmx->vmcs01.shadow_vmcs);
                        vmcs_load(vmx->loaded_vmcs->vmcs);