7 files changed, 72 insertions, 70 deletions

diff --git a/arch/s390/include/asm/pgtable.h b/arch/s390/include/asm/pgtable.h
index 4cd91ac42f46..d95012f9e77f 100644
--- a/arch/s390/include/asm/pgtable.h
+++ b/arch/s390/include/asm/pgtable.h
@@ -834,7 +834,7 @@ struct gmap_pgtable {
  */
 struct gmap_notifier {
         struct list_head list;
-        void (*notifier_call)(struct gmap *gmap, unsigned long address);
+        void (*notifier_call)(struct gmap *gmap, unsigned long gaddr);
 };
 
 struct gmap *gmap_alloc(struct mm_struct *mm);
@@ -844,12 +844,12 @@ void gmap_disable(struct gmap *gmap);
 int gmap_map_segment(struct gmap *gmap, unsigned long from,
                      unsigned long to, unsigned long len);
 int gmap_unmap_segment(struct gmap *gmap, unsigned long to, unsigned long len);
-unsigned long __gmap_translate(unsigned long address, struct gmap *);
-unsigned long gmap_translate(unsigned long address, struct gmap *);
-unsigned long __gmap_fault(unsigned long address, struct gmap *);
-unsigned long gmap_fault(unsigned long address, struct gmap *);
-void gmap_discard(unsigned long from, unsigned long to, struct gmap *);
-void __gmap_zap(unsigned long address, struct gmap *);
+unsigned long __gmap_translate(struct gmap *, unsigned long gaddr);
+unsigned long gmap_translate(struct gmap *, unsigned long gaddr);
+unsigned long __gmap_fault(struct gmap *, unsigned long gaddr);
+unsigned long gmap_fault(struct gmap *, unsigned long gaddr);
+void gmap_discard(struct gmap *, unsigned long from, unsigned long to);
+void __gmap_zap(struct gmap *, unsigned long gaddr);
 bool gmap_test_and_clear_dirty(unsigned long address, struct gmap *);
 
 
diff --git a/arch/s390/kvm/diag.c b/arch/s390/kvm/diag.c
index 59bd8f991b98..b374b6cb7785 100644
--- a/arch/s390/kvm/diag.c
+++ b/arch/s390/kvm/diag.c
@@ -37,13 +37,13 @@ static int diag_release_pages(struct kvm_vcpu *vcpu)
 
         /* we checked for start > end above */
         if (end < prefix || start >= prefix + 2 * PAGE_SIZE) {
-                gmap_discard(start, end, vcpu->arch.gmap);
+                gmap_discard(vcpu->arch.gmap, start, end);
         } else {
                 if (start < prefix)
-                        gmap_discard(start, prefix, vcpu->arch.gmap);
+                        gmap_discard(vcpu->arch.gmap, start, prefix);
                 if (end >= prefix)
-                        gmap_discard(prefix + 2 * PAGE_SIZE,
-                                     end, vcpu->arch.gmap);
+                        gmap_discard(vcpu->arch.gmap,
+                                     prefix + 2 * PAGE_SIZE, end);
         }
         return 0;
 }
diff --git a/arch/s390/kvm/interrupt.c b/arch/s390/kvm/interrupt.c
index ba89bbbd2ed5..60a5cf40d49a 100644
--- a/arch/s390/kvm/interrupt.c
+++ b/arch/s390/kvm/interrupt.c
@@ -1241,7 +1241,7 @@ static int kvm_s390_adapter_map(struct kvm *kvm, unsigned int id, __u64 addr)
         }
         INIT_LIST_HEAD(&map->list);
         map->guest_addr = addr;
-        map->addr = gmap_translate(addr, kvm->arch.gmap);
+        map->addr = gmap_translate(kvm->arch.gmap, addr);
         if (map->addr == -EFAULT) {
                 ret = -EFAULT;
                 goto out;
diff --git a/arch/s390/kvm/kvm-s390.c b/arch/s390/kvm/kvm-s390.c
index c2caa175320c..5c877c8e4494 100644
--- a/arch/s390/kvm/kvm-s390.c
+++ b/arch/s390/kvm/kvm-s390.c
@@ -1096,7 +1096,7 @@ long kvm_arch_fault_in_page(struct kvm_vcpu *vcpu, gpa_t gpa, int writable)
         hva_t hva;
         long rc;
 
-        hva = gmap_fault(gpa, vcpu->arch.gmap);
+        hva = gmap_fault(vcpu->arch.gmap, gpa);
         if (IS_ERR_VALUE(hva))
                 return (long)hva;
         down_read(&mm->mmap_sem);
@@ -1683,7 +1683,7 @@ long kvm_arch_vcpu_ioctl(struct file *filp,
         }
 #endif
         case KVM_S390_VCPU_FAULT: {
-                r = gmap_fault(arg, vcpu->arch.gmap);
+                r = gmap_fault(vcpu->arch.gmap, arg);
                 if (!IS_ERR_VALUE(r))
                         r = 0;
                 break;
diff --git a/arch/s390/kvm/priv.c b/arch/s390/kvm/priv.c
index d806f2cfde16..72bb2dd8b9cd 100644
--- a/arch/s390/kvm/priv.c
+++ b/arch/s390/kvm/priv.c
@@ -729,7 +729,7 @@ static int handle_essa(struct kvm_vcpu *vcpu)
                         /* invalid entry */
                         break;
                 /* try to free backing */
-                __gmap_zap(cbrle, gmap);
+                __gmap_zap(gmap, cbrle);
         }
         up_read(&gmap->mm->mmap_sem);
         if (i < entries)
diff --git a/arch/s390/mm/fault.c b/arch/s390/mm/fault.c
index 3f3b35403d0a..4880399d040e 100644
--- a/arch/s390/mm/fault.c
+++ b/arch/s390/mm/fault.c
@@ -445,7 +445,7 @@ static inline int do_exception(struct pt_regs *regs, int access)
         gmap = (struct gmap *)
                 ((current->flags & PF_VCPU) ? S390_lowcore.gmap : 0);
         if (gmap) {
-                address = __gmap_fault(address, gmap);
+                address = __gmap_fault(gmap, address);
                 if (address == -EFAULT) {
                         fault = VM_FAULT_BADMAP;
                         goto out_up;
diff --git a/arch/s390/mm/pgtable.c b/arch/s390/mm/pgtable.c
index c09820dce81c..16ca8617f2e1 100644
--- a/arch/s390/mm/pgtable.c
+++ b/arch/s390/mm/pgtable.c
@@ -295,7 +295,7 @@ static int gmap_alloc_table(struct gmap *gmap,
 /**
  * gmap_unmap_segment - unmap segment from the guest address space
  * @gmap: pointer to the guest address space structure
- * @addr: address in the guest address space
+ * @to: address in the guest address space
  * @len: length of the memory area to unmap
  *
  * Returns 0 if the unmap succeeded, -EINVAL if not.
@@ -348,6 +348,7 @@ EXPORT_SYMBOL_GPL(gmap_unmap_segment);
  * @gmap: pointer to the guest address space structure
  * @from: source address in the parent address space
  * @to: target address in the guest address space
+ * @len: length of the memory area to map
  *
  * Returns 0 if the mmap succeeded, -EINVAL or -ENOMEM if not.
  */
@@ -405,30 +406,30 @@ out_unmap:
 }
 EXPORT_SYMBOL_GPL(gmap_map_segment);
 
-static unsigned long *gmap_table_walk(unsigned long address, struct gmap *gmap)
+static unsigned long *gmap_table_walk(struct gmap *gmap, unsigned long gaddr)
 {
         unsigned long *table;
 
-        table = gmap->table + ((address >> 53) & 0x7ff);
+        table = gmap->table + ((gaddr >> 53) & 0x7ff);
         if (unlikely(*table & _REGION_ENTRY_INVALID))
                 return ERR_PTR(-EFAULT);
         table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
-        table = table + ((address >> 42) & 0x7ff);
+        table = table + ((gaddr >> 42) & 0x7ff);
         if (unlikely(*table & _REGION_ENTRY_INVALID))
                 return ERR_PTR(-EFAULT);
         table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
-        table = table + ((address >> 31) & 0x7ff);
+        table = table + ((gaddr >> 31) & 0x7ff);
         if (unlikely(*table & _REGION_ENTRY_INVALID))
                 return ERR_PTR(-EFAULT);
         table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
-        table = table + ((address >> 20) & 0x7ff);
+        table = table + ((gaddr >> 20) & 0x7ff);
         return table;
 }
 
 /**
  * __gmap_translate - translate a guest address to a user space address
- * @address: guest address
  * @gmap: pointer to guest mapping meta data structure
+ * @gaddr: guest address
  *
  * Returns user space address which corresponds to the guest address or
  * -EFAULT if no such mapping exists.
@@ -436,14 +437,14 @@ static unsigned long *gmap_table_walk(unsigned long address, struct gmap *gmap)
  * The mmap_sem of the mm that belongs to the address space must be held
  * when this function gets called.
  */
-unsigned long __gmap_translate(unsigned long address, struct gmap *gmap)
+unsigned long __gmap_translate(struct gmap *gmap, unsigned long gaddr)
 {
         unsigned long *segment_ptr, vmaddr, segment;
         struct gmap_pgtable *mp;
         struct page *page;
 
-        current->thread.gmap_addr = address;
-        segment_ptr = gmap_table_walk(address, gmap);
+        current->thread.gmap_addr = gaddr;
+        segment_ptr = gmap_table_walk(gmap, gaddr);
         if (IS_ERR(segment_ptr))
                 return PTR_ERR(segment_ptr);
         /* Convert the gmap address to an mm address. */
@@ -451,10 +452,10 @@ unsigned long __gmap_translate(unsigned long address, struct gmap *gmap)
         if (!(segment & _SEGMENT_ENTRY_INVALID)) {
                 page = pfn_to_page(segment >> PAGE_SHIFT);
                 mp = (struct gmap_pgtable *) page->index;
-                return mp->vmaddr | (address & ~PMD_MASK);
+                return mp->vmaddr | (gaddr & ~PMD_MASK);
         } else if (segment & _SEGMENT_ENTRY_PROTECT) {
                 vmaddr = segment & _SEGMENT_ENTRY_ORIGIN;
-                return vmaddr | (address & ~PMD_MASK);
+                return vmaddr | (gaddr & ~PMD_MASK);
         }
         return -EFAULT;
 }
@@ -462,26 +463,27 @@ EXPORT_SYMBOL_GPL(__gmap_translate);
 
 /**
  * gmap_translate - translate a guest address to a user space address
- * @address: guest address
  * @gmap: pointer to guest mapping meta data structure
+ * @gaddr: guest address
  *
  * Returns user space address which corresponds to the guest address or
  * -EFAULT if no such mapping exists.
  * This function does not establish potentially missing page table entries.
  */
-unsigned long gmap_translate(unsigned long address, struct gmap *gmap)
+unsigned long gmap_translate(struct gmap *gmap, unsigned long gaddr)
 {
         unsigned long rc;
 
         down_read(&gmap->mm->mmap_sem);
-        rc = __gmap_translate(address, gmap);
+        rc = __gmap_translate(gmap, gaddr);
         up_read(&gmap->mm->mmap_sem);
         return rc;
 }
 EXPORT_SYMBOL_GPL(gmap_translate);
 
-static int gmap_connect_pgtable(unsigned long address, unsigned long segment,
-                                unsigned long *segment_ptr, struct gmap *gmap)
+static int gmap_connect_pgtable(struct gmap *gmap, unsigned long gaddr,
+                                unsigned long segment,
+                                unsigned long *segment_ptr)
 {
         unsigned long vmaddr;
         struct vm_area_struct *vma;
@@ -521,7 +523,7 @@ static int gmap_connect_pgtable(unsigned long address, unsigned long segment,
         mp = (struct gmap_pgtable *) page->index;
         rmap->gmap = gmap;
         rmap->entry = segment_ptr;
-        rmap->vmaddr = address & PMD_MASK;
+        rmap->vmaddr = gaddr & PMD_MASK;
         spin_lock(&mm->page_table_lock);
         if (*segment_ptr == segment) {
                 list_add(&rmap->list, &mp->mapper);
@@ -560,15 +562,15 @@ static void gmap_disconnect_pgtable(struct mm_struct *mm, unsigned long *table)
 /*
  * this function is assumed to be called with mmap_sem held
  */
-unsigned long __gmap_fault(unsigned long address, struct gmap *gmap)
+unsigned long __gmap_fault(struct gmap *gmap, unsigned long gaddr)
 {
         unsigned long *segment_ptr, segment;
         struct gmap_pgtable *mp;
         struct page *page;
         int rc;
 
-        current->thread.gmap_addr = address;
-        segment_ptr = gmap_table_walk(address, gmap);
+        current->thread.gmap_addr = gaddr;
+        segment_ptr = gmap_table_walk(gmap, gaddr);
         if (IS_ERR(segment_ptr))
                 return -EFAULT;
         /* Convert the gmap address to an mm address. */
@@ -578,24 +580,24 @@ unsigned long __gmap_fault(unsigned long address, struct gmap *gmap)
                         /* Page table is present */
                         page = pfn_to_page(segment >> PAGE_SHIFT);
                         mp = (struct gmap_pgtable *) page->index;
-                        return mp->vmaddr | (address & ~PMD_MASK);
+                        return mp->vmaddr | (gaddr & ~PMD_MASK);
                 }
                 if (!(segment & _SEGMENT_ENTRY_PROTECT))
                         /* Nothing mapped in the gmap address space. */
                         break;
-                rc = gmap_connect_pgtable(address, segment, segment_ptr, gmap);
+                rc = gmap_connect_pgtable(gmap, gaddr, segment, segment_ptr);
                 if (rc)
                         return rc;
         }
         return -EFAULT;
 }
 
-unsigned long gmap_fault(unsigned long address, struct gmap *gmap)
+unsigned long gmap_fault(struct gmap *gmap, unsigned long gaddr)
 {
         unsigned long rc;
 
         down_read(&gmap->mm->mmap_sem);
-        rc = __gmap_fault(address, gmap);
+        rc = __gmap_fault(gmap, gaddr);
         up_read(&gmap->mm->mmap_sem);
 
         return rc;
@@ -620,14 +622,14 @@ static void gmap_zap_swap_entry(swp_entry_t entry, struct mm_struct *mm)
 /**
  * The mm->mmap_sem lock must be held
  */
-static void gmap_zap_unused(struct mm_struct *mm, unsigned long address)
+static void gmap_zap_unused(struct mm_struct *mm, unsigned long vmaddr)
 {
         unsigned long ptev, pgstev;
         spinlock_t *ptl;
         pgste_t pgste;
         pte_t *ptep, pte;
 
-        ptep = get_locked_pte(mm, address, &ptl);
+        ptep = get_locked_pte(mm, vmaddr, &ptl);
         if (unlikely(!ptep))
                 return;
         pte = *ptep;
@@ -640,7 +642,7 @@ static void gmap_zap_unused(struct mm_struct *mm, unsigned long address)
         if (((pgstev & _PGSTE_GPS_USAGE_MASK) == _PGSTE_GPS_USAGE_UNUSED) ||
             ((pgstev & _PGSTE_GPS_ZERO) && (ptev & _PAGE_INVALID))) {
                 gmap_zap_swap_entry(pte_to_swp_entry(pte), mm);
-                pte_clear(mm, address, ptep);
+                pte_clear(mm, vmaddr, ptep);
         }
         pgste_set_unlock(ptep, pgste);
 out_pte:
@@ -650,14 +652,14 @@ out_pte:
 /*
  * this function is assumed to be called with mmap_sem held
  */
-void __gmap_zap(unsigned long address, struct gmap *gmap)
+void __gmap_zap(struct gmap *gmap, unsigned long gaddr)
 {
         unsigned long *table, *segment_ptr;
-        unsigned long segment, pgstev, ptev;
+        unsigned long segment, vmaddr, pgstev, ptev;
         struct gmap_pgtable *mp;
         struct page *page;
 
-        segment_ptr = gmap_table_walk(address, gmap);
+        segment_ptr = gmap_table_walk(gmap, gaddr);
         if (IS_ERR(segment_ptr))
                 return;
         segment = *segment_ptr;
@@ -665,61 +667,61 @@ void __gmap_zap(unsigned long address, struct gmap *gmap)
                 return;
         page = pfn_to_page(segment >> PAGE_SHIFT);
         mp = (struct gmap_pgtable *) page->index;
-        address = mp->vmaddr | (address & ~PMD_MASK);
+        vmaddr = mp->vmaddr | (gaddr & ~PMD_MASK);
         /* Page table is present */
         table = (unsigned long *)(segment & _SEGMENT_ENTRY_ORIGIN);
-        table = table + ((address >> 12) & 0xff);
+        table = table + ((vmaddr >> 12) & 0xff);
         pgstev = table[PTRS_PER_PTE];
         ptev = table[0];
         /* quick check, checked again with locks held */
         if (((pgstev & _PGSTE_GPS_USAGE_MASK) == _PGSTE_GPS_USAGE_UNUSED) ||
             ((pgstev & _PGSTE_GPS_ZERO) && (ptev & _PAGE_INVALID)))
-                gmap_zap_unused(gmap->mm, address);
+                gmap_zap_unused(gmap->mm, vmaddr);
 }
 EXPORT_SYMBOL_GPL(__gmap_zap);
 
-void gmap_discard(unsigned long from, unsigned long to, struct gmap *gmap)
+void gmap_discard(struct gmap *gmap, unsigned long from, unsigned long to)
 {
 
-        unsigned long *table, address, size;
+        unsigned long *table, gaddr, size;
         struct vm_area_struct *vma;
         struct gmap_pgtable *mp;
         struct page *page;
 
         down_read(&gmap->mm->mmap_sem);
-        address = from;
-        while (address < to) {
+        gaddr = from;
+        while (gaddr < to) {
                 /* Walk the gmap address space page table */
-                table = gmap->table + ((address >> 53) & 0x7ff);
+                table = gmap->table + ((gaddr >> 53) & 0x7ff);
                 if (unlikely(*table & _REGION_ENTRY_INVALID)) {
-                        address = (address + PMD_SIZE) & PMD_MASK;
+                        gaddr = (gaddr + PMD_SIZE) & PMD_MASK;
                         continue;
                 }
                 table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
-                table = table + ((address >> 42) & 0x7ff);
+                table = table + ((gaddr >> 42) & 0x7ff);
                 if (unlikely(*table & _REGION_ENTRY_INVALID)) {
-                        address = (address + PMD_SIZE) & PMD_MASK;
+                        gaddr = (gaddr + PMD_SIZE) & PMD_MASK;
                         continue;
                 }
                 table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
-                table = table + ((address >> 31) & 0x7ff);
+                table = table + ((gaddr >> 31) & 0x7ff);
                 if (unlikely(*table & _REGION_ENTRY_INVALID)) {
-                        address = (address + PMD_SIZE) & PMD_MASK;
+                        gaddr = (gaddr + PMD_SIZE) & PMD_MASK;
                         continue;
                 }
                 table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
-                table = table + ((address >> 20) & 0x7ff);
+                table = table + ((gaddr >> 20) & 0x7ff);
                 if (unlikely(*table & _SEGMENT_ENTRY_INVALID)) {
-                        address = (address + PMD_SIZE) & PMD_MASK;
+                        gaddr = (gaddr + PMD_SIZE) & PMD_MASK;
                         continue;
                 }
                 page = pfn_to_page(*table >> PAGE_SHIFT);
                 mp = (struct gmap_pgtable *) page->index;
                 vma = find_vma(gmap->mm, mp->vmaddr);
-                size = min(to - address, PMD_SIZE - (address & ~PMD_MASK));
-                zap_page_range(vma, mp->vmaddr | (address & ~PMD_MASK),
+                size = min(to - gaddr, PMD_SIZE - (gaddr & ~PMD_MASK));
+                zap_page_range(vma, mp->vmaddr | (gaddr & ~PMD_MASK),
                                size, NULL);
-                address = (address + PMD_SIZE) & PMD_MASK;
+                gaddr = (gaddr + PMD_SIZE) & PMD_MASK;
         }
         up_read(&gmap->mm->mmap_sem);
 }
@@ -755,7 +757,7 @@ EXPORT_SYMBOL_GPL(gmap_unregister_ipte_notifier);
 /**
  * gmap_ipte_notify - mark a range of ptes for invalidation notification
  * @gmap: pointer to guest mapping meta data structure
- * @start: virtual address in the guest address space
+ * @gaddr: virtual address in the guest address space
  * @len: size of area
  *
  * Returns 0 if for each page in the given range a gmap mapping exists and
@@ -763,7 +765,7 @@ EXPORT_SYMBOL_GPL(gmap_unregister_ipte_notifier);
  * for one or more pages -EFAULT is returned. If no memory could be allocated
  * -ENOMEM is returned. This function establishes missing page table entries.
  */
-int gmap_ipte_notify(struct gmap *gmap, unsigned long start, unsigned long len)
+int gmap_ipte_notify(struct gmap *gmap, unsigned long gaddr, unsigned long len)
 {
         unsigned long addr;
         spinlock_t *ptl;
@@ -771,12 +773,12 @@ int gmap_ipte_notify(struct gmap *gmap, unsigned long start, unsigned long len)
         pgste_t pgste;
         int rc = 0;
 
-        if ((start & ~PAGE_MASK) || (len & ~PAGE_MASK))
+        if ((gaddr & ~PAGE_MASK) || (len & ~PAGE_MASK))
                 return -EINVAL;
         down_read(&gmap->mm->mmap_sem);
         while (len) {
                 /* Convert gmap address and connect the page tables */
-                addr = __gmap_fault(start, gmap);
+                addr = __gmap_fault(gmap, gaddr);
                 if (IS_ERR_VALUE(addr)) {
                         rc = addr;
                         break;
@@ -796,7 +798,7 @@ int gmap_ipte_notify(struct gmap *gmap, unsigned long start, unsigned long len)
                         pgste = pgste_get_lock(ptep);
                         pgste_val(pgste) |= PGSTE_IN_BIT;
                         pgste_set_unlock(ptep, pgste);
-                        start += PAGE_SIZE;
+                        gaddr += PAGE_SIZE;
                         len -= PAGE_SIZE;
                 }
                 spin_unlock(ptl);