KVM: s390: Rename some functions in gaccess.c

Rename some functions in gaccess.c to add a _gva or _gpa suffix to
indicate whether the function accepts a virtual or a guest-absolute
address.

This makes it easier to understand the code.

Reviewed-by: Steffen Eiden <seiden@linux.ibm.com>
Reviewed-by: Christoph Schlameuss <schlameuss@linux.ibm.com>
Acked-by: Heiko Carstens <hca@linux.ibm.com>
Signed-off-by: Claudio Imbrenda <imbrenda@linux.ibm.com>

diff --git a/arch/s390/kvm/gaccess.c b/arch/s390/kvm/gaccess.c
index d8347f7cbe513e34ce667d5aa6fd3852c953431c..9df868bddf9a1bfaf1d0fcfc0028b34f351199f7 100644 (file)
--- a/arch/s390/kvm/gaccess.c
+++ b/arch/s390/kvm/gaccess.c
@@ -397,7 +397,7 @@ static int deref_table(struct kvm *kvm, unsigned long gpa, unsigned long *val)
 }
 
 /**
- * guest_translate - translate a guest virtual into a guest absolute address
+ * guest_translate_gva() - translate a guest virtual into a guest absolute address
  * @vcpu: virtual cpu
  * @gva: guest virtual address
  * @gpa: points to where guest physical (absolute) address should be stored
@@ -417,9 +417,9 @@ static int deref_table(struct kvm *kvm, unsigned long gpa, unsigned long *val)
  *           the returned value is the program interruption code as defined
  *           by the architecture
  */
-static unsigned long guest_translate(struct kvm_vcpu *vcpu, unsigned long gva,
-                                    unsigned long *gpa, const union asce asce,
-                                    enum gacc_mode mode, enum prot_type *prot)
+static unsigned long guest_translate_gva(struct kvm_vcpu *vcpu, unsigned long gva,
+                                        unsigned long *gpa, const union asce asce,
+                                        enum gacc_mode mode, enum prot_type *prot)
 {
        union vaddress vaddr = {.addr = gva};
        union raddress raddr = {.addr = gva};
@@ -600,8 +600,8 @@ static int low_address_protection_enabled(struct kvm_vcpu *vcpu,
        return 1;
 }
 
-static int vm_check_access_key(struct kvm *kvm, u8 access_key,
-                              enum gacc_mode mode, gpa_t gpa)
+static int vm_check_access_key_gpa(struct kvm *kvm, u8 access_key,
+                                  enum gacc_mode mode, gpa_t gpa)
 {
        u8 storage_key, access_control;
        bool fetch_protected;
@@ -663,9 +663,9 @@ static bool storage_prot_override_applies(u8 access_control)
        return access_control == PAGE_SPO_ACC;
 }
 
-static int vcpu_check_access_key(struct kvm_vcpu *vcpu, u8 access_key,
-                                enum gacc_mode mode, union asce asce, gpa_t gpa,
-                                unsigned long ga, unsigned int len)
+static int vcpu_check_access_key_gpa(struct kvm_vcpu *vcpu, u8 access_key,
+                                    enum gacc_mode mode, union asce asce, gpa_t gpa,
+                                    unsigned long ga, unsigned int len)
 {
        u8 storage_key, access_control;
        unsigned long hva;
@@ -757,7 +757,7 @@ static int guest_range_to_gpas(struct kvm_vcpu *vcpu, unsigned long ga, u8 ar,
                        return trans_exc(vcpu, PGM_PROTECTION, ga, ar, mode,
                                         PROT_TYPE_LA);
                if (psw_bits(*psw).dat) {
-                       rc = guest_translate(vcpu, ga, &gpa, asce, mode, &prot);
+                       rc = guest_translate_gva(vcpu, ga, &gpa, asce, mode, &prot);
                        if (rc < 0)
                                return rc;
                } else {
@@ -769,8 +769,7 @@ static int guest_range_to_gpas(struct kvm_vcpu *vcpu, unsigned long ga, u8 ar,
                }
                if (rc)
                        return trans_exc(vcpu, rc, ga, ar, mode, prot);
-               rc = vcpu_check_access_key(vcpu, access_key, mode, asce, gpa, ga,
-                                          fragment_len);
+               rc = vcpu_check_access_key_gpa(vcpu, access_key, mode, asce, gpa, ga, fragment_len);
                if (rc)
                        return trans_exc(vcpu, rc, ga, ar, mode, PROT_TYPE_KEYC);
                if (gpas)
@@ -782,8 +781,8 @@ static int guest_range_to_gpas(struct kvm_vcpu *vcpu, unsigned long ga, u8 ar,
        return 0;
 }
 
-static int access_guest_page(struct kvm *kvm, enum gacc_mode mode, gpa_t gpa,
-                            void *data, unsigned int len)
+static int access_guest_page_gpa(struct kvm *kvm, enum gacc_mode mode, gpa_t gpa,
+                                void *data, unsigned int len)
 {
        const unsigned int offset = offset_in_page(gpa);
        const gfn_t gfn = gpa_to_gfn(gpa);
@@ -798,9 +797,8 @@ static int access_guest_page(struct kvm *kvm, enum gacc_mode mode, gpa_t gpa,
        return rc;
 }
 
-static int
-access_guest_page_with_key(struct kvm *kvm, enum gacc_mode mode, gpa_t gpa,
-                          void *data, unsigned int len, u8 access_key)
+static int access_guest_page_with_key_gpa(struct kvm *kvm, enum gacc_mode mode, gpa_t gpa,
+                                         void *data, unsigned int len, u8 access_key)
 {
        struct kvm_memory_slot *slot;
        bool writable;
@@ -808,7 +806,7 @@ access_guest_page_with_key(struct kvm *kvm, enum gacc_mode mode, gpa_t gpa,
        hva_t hva;
        int rc;
 
-       gfn = gpa >> PAGE_SHIFT;
+       gfn = gpa_to_gfn(gpa);
        slot = gfn_to_memslot(kvm, gfn);
        hva = gfn_to_hva_memslot_prot(slot, gfn, &writable);
 
@@ -841,7 +839,7 @@ int access_guest_abs_with_key(struct kvm *kvm, gpa_t gpa, void *data,
 
        while (min(PAGE_SIZE - offset, len) > 0) {
                fragment_len = min(PAGE_SIZE - offset, len);
-               rc = access_guest_page_with_key(kvm, mode, gpa, data, fragment_len, access_key);
+               rc = access_guest_page_with_key_gpa(kvm, mode, gpa, data, fragment_len, access_key);
                if (rc)
                        return rc;
                offset = 0;
@@ -901,15 +899,14 @@ int access_guest_with_key(struct kvm_vcpu *vcpu, unsigned long ga, u8 ar,
        for (idx = 0; idx < nr_pages; idx++) {
                fragment_len = min(PAGE_SIZE - offset_in_page(gpas[idx]), len);
                if (try_fetch_prot_override && fetch_prot_override_applies(ga, fragment_len)) {
-                       rc = access_guest_page(vcpu->kvm, mode, gpas[idx],
-                                              data, fragment_len);
+                       rc = access_guest_page_gpa(vcpu->kvm, mode, gpas[idx], data, fragment_len);
                } else {
-                       rc = access_guest_page_with_key(vcpu->kvm, mode, gpas[idx],
-                                                       data, fragment_len, access_key);
+                       rc = access_guest_page_with_key_gpa(vcpu->kvm, mode, gpas[idx],
+                                                           data, fragment_len, access_key);
                }
                if (rc == PGM_PROTECTION && try_storage_prot_override)
-                       rc = access_guest_page_with_key(vcpu->kvm, mode, gpas[idx],
-                                                       data, fragment_len, PAGE_SPO_ACC);
+                       rc = access_guest_page_with_key_gpa(vcpu->kvm, mode, gpas[idx],
+                                                           data, fragment_len, PAGE_SPO_ACC);
                if (rc)
                        break;
                len -= fragment_len;
@@ -943,7 +940,7 @@ int access_guest_real(struct kvm_vcpu *vcpu, unsigned long gra,
        while (len && !rc) {
                gpa = kvm_s390_real_to_abs(vcpu, gra);
                fragment_len = min(PAGE_SIZE - offset_in_page(gpa), len);
-               rc = access_guest_page(vcpu->kvm, mode, gpa, data, fragment_len);
+               rc = access_guest_page_gpa(vcpu->kvm, mode, gpa, data, fragment_len);
                len -= fragment_len;
                gra += fragment_len;
                data += fragment_len;
@@ -1134,7 +1131,7 @@ int check_gpa_range(struct kvm *kvm, unsigned long gpa, unsigned long length,
 
        while (length && !rc) {
                fragment_len = min(PAGE_SIZE - offset_in_page(gpa), length);
-               rc = vm_check_access_key(kvm, access_key, mode, gpa);
+               rc = vm_check_access_key_gpa(kvm, access_key, mode, gpa);
                length -= fragment_len;
                gpa += fragment_len;
        }