[RFC v1 1/2] KVM: PPC: Book3S HV: rename all variables in book3s_hv_uvmem.c
Ram Pai
linuxram at us.ibm.com
Mon Oct 12 18:27:42 AEDT 2020
Preparing this file to be one of the many backends. Since this file
supports Ultravisor backend, renaming all variable from kvmppc_*
to uvmem_*. This is to avoid clash with some generic top level
functions to be defined in the next patch.
Signed-off-by: Ram Pai <linuxram at us.ibm.com>
---
arch/powerpc/kvm/book3s_hv_uvmem.c | 210 ++++++++++++++++++-------------------
1 file changed, 105 insertions(+), 105 deletions(-)
diff --git a/arch/powerpc/kvm/book3s_hv_uvmem.c b/arch/powerpc/kvm/book3s_hv_uvmem.c
index 7705d55..b79affc 100644
--- a/arch/powerpc/kvm/book3s_hv_uvmem.c
+++ b/arch/powerpc/kvm/book3s_hv_uvmem.c
@@ -95,9 +95,9 @@
#include <asm/kvm_ppc.h>
#include <asm/kvm_book3s_uvmem.h>
-static struct dev_pagemap kvmppc_uvmem_pgmap;
-static unsigned long *kvmppc_uvmem_bitmap;
-static DEFINE_SPINLOCK(kvmppc_uvmem_bitmap_lock);
+static struct dev_pagemap uvmem_pgmap;
+static unsigned long *uvmem_bitmap;
+static DEFINE_SPINLOCK(uvmem_bitmap_lock);
/*
* States of a GFN
@@ -221,13 +221,13 @@
#define KVMPPC_GFN_FLAG_MASK (KVMPPC_GFN_SECURE | KVMPPC_GFN_SHARED)
#define KVMPPC_GFN_PFN_MASK (~KVMPPC_GFN_FLAG_MASK)
-struct kvmppc_uvmem_slot {
+struct uvmem_slot {
struct list_head list;
unsigned long nr_pfns;
unsigned long base_pfn;
unsigned long *pfns;
};
-struct kvmppc_uvmem_page_pvt {
+struct uvmem_page_pvt {
struct kvm *kvm;
unsigned long gpa;
bool skip_page_out;
@@ -237,15 +237,15 @@ struct kvmppc_uvmem_page_pvt {
bool kvmppc_uvmem_available(void)
{
/*
- * If kvmppc_uvmem_bitmap != NULL, then there is an ultravisor
+ * If uvmem_bitmap != NULL, then there is an ultravisor
* and our data structures have been initialized successfully.
*/
- return !!kvmppc_uvmem_bitmap;
+ return !!uvmem_bitmap;
}
-int kvmppc_uvmem_slot_init(struct kvm *kvm, const struct kvm_memory_slot *slot)
+static int uvmem_slot_init(struct kvm *kvm, const struct kvm_memory_slot *slot)
{
- struct kvmppc_uvmem_slot *p;
+ struct uvmem_slot *p;
p = kzalloc(sizeof(*p), GFP_KERNEL);
if (!p)
@@ -268,9 +268,9 @@ int kvmppc_uvmem_slot_init(struct kvm *kvm, const struct kvm_memory_slot *slot)
/*
* All device PFNs are already released by the time we come here.
*/
-void kvmppc_uvmem_slot_free(struct kvm *kvm, const struct kvm_memory_slot *slot)
+static void uvmem_slot_free(struct kvm *kvm, const struct kvm_memory_slot *slot)
{
- struct kvmppc_uvmem_slot *p, *next;
+ struct uvmem_slot *p, *next;
mutex_lock(&kvm->arch.uvmem_lock);
list_for_each_entry_safe(p, next, &kvm->arch.uvmem_pfns, list) {
@@ -284,10 +284,10 @@ void kvmppc_uvmem_slot_free(struct kvm *kvm, const struct kvm_memory_slot *slot)
mutex_unlock(&kvm->arch.uvmem_lock);
}
-static void kvmppc_mark_gfn(unsigned long gfn, struct kvm *kvm,
+static void uvmem_mark_gfn(unsigned long gfn, struct kvm *kvm,
unsigned long flag, unsigned long uvmem_pfn)
{
- struct kvmppc_uvmem_slot *p;
+ struct uvmem_slot *p;
list_for_each_entry(p, &kvm->arch.uvmem_pfns, list) {
if (gfn >= p->base_pfn && gfn < p->base_pfn + p->nr_pfns) {
@@ -303,35 +303,35 @@ static void kvmppc_mark_gfn(unsigned long gfn, struct kvm *kvm,
}
/* mark the GFN as secure-GFN associated with @uvmem pfn device-PFN. */
-static void kvmppc_gfn_secure_uvmem_pfn(unsigned long gfn,
+static void uvmem_gfn_secure_uvmem_pfn(unsigned long gfn,
unsigned long uvmem_pfn, struct kvm *kvm)
{
- kvmppc_mark_gfn(gfn, kvm, KVMPPC_GFN_UVMEM_PFN, uvmem_pfn);
+ uvmem_mark_gfn(gfn, kvm, KVMPPC_GFN_UVMEM_PFN, uvmem_pfn);
}
/* mark the GFN as secure-GFN associated with a memory-PFN. */
-static void kvmppc_gfn_secure_mem_pfn(unsigned long gfn, struct kvm *kvm)
+static void uvmem_gfn_secure_mem_pfn(unsigned long gfn, struct kvm *kvm)
{
- kvmppc_mark_gfn(gfn, kvm, KVMPPC_GFN_MEM_PFN, 0);
+ uvmem_mark_gfn(gfn, kvm, KVMPPC_GFN_MEM_PFN, 0);
}
/* mark the GFN as a shared GFN. */
-static void kvmppc_gfn_shared(unsigned long gfn, struct kvm *kvm)
+static void uvmem_gfn_shared(unsigned long gfn, struct kvm *kvm)
{
- kvmppc_mark_gfn(gfn, kvm, KVMPPC_GFN_SHARED, 0);
+ uvmem_mark_gfn(gfn, kvm, KVMPPC_GFN_SHARED, 0);
}
/* mark the GFN as a non-existent GFN. */
-static void kvmppc_gfn_remove(unsigned long gfn, struct kvm *kvm)
+static void uvmem_gfn_remove(unsigned long gfn, struct kvm *kvm)
{
- kvmppc_mark_gfn(gfn, kvm, 0, 0);
+ uvmem_mark_gfn(gfn, kvm, 0, 0);
}
/* return true, if the GFN is a secure-GFN backed by a secure-PFN */
-static bool kvmppc_gfn_is_uvmem_pfn(unsigned long gfn, struct kvm *kvm,
+static bool uvmem_gfn_is_uvmem_pfn(unsigned long gfn, struct kvm *kvm,
unsigned long *uvmem_pfn)
{
- struct kvmppc_uvmem_slot *p;
+ struct uvmem_slot *p;
list_for_each_entry(p, &kvm->arch.uvmem_pfns, list) {
if (gfn >= p->base_pfn && gfn < p->base_pfn + p->nr_pfns) {
@@ -356,10 +356,10 @@ static bool kvmppc_gfn_is_uvmem_pfn(unsigned long gfn, struct kvm *kvm,
*
* Must be called with kvm->arch.uvmem_lock held.
*/
-static bool kvmppc_next_nontransitioned_gfn(const struct kvm_memory_slot *memslot,
+static bool uvmem_next_nontransitioned_gfn(const struct kvm_memory_slot *memslot,
struct kvm *kvm, unsigned long *gfn)
{
- struct kvmppc_uvmem_slot *p;
+ struct uvmem_slot *p;
bool ret = false;
unsigned long i;
@@ -370,7 +370,7 @@ static bool kvmppc_next_nontransitioned_gfn(const struct kvm_memory_slot *memslo
return ret;
/*
* The code below assumes, one to one correspondence between
- * kvmppc_uvmem_slot and memslot.
+ * uvmem_slot and memslot.
*/
for (i = *gfn; i < p->base_pfn + p->nr_pfns; i++) {
unsigned long index = i - p->base_pfn;
@@ -384,7 +384,7 @@ static bool kvmppc_next_nontransitioned_gfn(const struct kvm_memory_slot *memslo
return ret;
}
-static int kvmppc_memslot_page_merge(struct kvm *kvm,
+static int uvmem_memslot_page_merge(struct kvm *kvm,
const struct kvm_memory_slot *memslot, bool merge)
{
unsigned long gfn = memslot->base_gfn;
@@ -418,23 +418,23 @@ static int kvmppc_memslot_page_merge(struct kvm *kvm,
return ret;
}
-static void __kvmppc_uvmem_memslot_delete(struct kvm *kvm,
+static void __uvmem_memslot_delete(struct kvm *kvm,
const struct kvm_memory_slot *memslot)
{
uv_unregister_mem_slot(kvm->arch.lpid, memslot->id);
- kvmppc_uvmem_slot_free(kvm, memslot);
- kvmppc_memslot_page_merge(kvm, memslot, true);
+ uvmem_slot_free(kvm, memslot);
+ uvmem_memslot_page_merge(kvm, memslot, true);
}
-static int __kvmppc_uvmem_memslot_create(struct kvm *kvm,
+static int __uvmem_memslot_create(struct kvm *kvm,
const struct kvm_memory_slot *memslot)
{
int ret = H_PARAMETER;
- if (kvmppc_memslot_page_merge(kvm, memslot, false))
+ if (uvmem_memslot_page_merge(kvm, memslot, false))
return ret;
- if (kvmppc_uvmem_slot_init(kvm, memslot))
+ if (uvmem_slot_init(kvm, memslot))
goto out1;
ret = uv_register_mem_slot(kvm->arch.lpid,
@@ -447,9 +447,9 @@ static int __kvmppc_uvmem_memslot_create(struct kvm *kvm,
}
return 0;
out:
- kvmppc_uvmem_slot_free(kvm, memslot);
+ uvmem_slot_free(kvm, memslot);
out1:
- kvmppc_memslot_page_merge(kvm, memslot, true);
+ uvmem_memslot_page_merge(kvm, memslot, true);
return ret;
}
@@ -462,7 +462,7 @@ unsigned long kvmppc_h_svm_init_start(struct kvm *kvm)
kvm->arch.secure_guest = KVMPPC_SECURE_INIT_START;
- if (!kvmppc_uvmem_bitmap)
+ if (!uvmem_bitmap)
return H_UNSUPPORTED;
/* Only radix guests can be secure guests */
@@ -478,7 +478,7 @@ unsigned long kvmppc_h_svm_init_start(struct kvm *kvm)
/* register the memslot */
slots = kvm_memslots(kvm);
kvm_for_each_memslot(memslot, slots) {
- ret = __kvmppc_uvmem_memslot_create(kvm, memslot);
+ ret = __uvmem_memslot_create(kvm, memslot);
if (ret)
break;
}
@@ -488,7 +488,7 @@ unsigned long kvmppc_h_svm_init_start(struct kvm *kvm)
kvm_for_each_memslot(m, slots) {
if (m == memslot)
break;
- __kvmppc_uvmem_memslot_delete(kvm, memslot);
+ __uvmem_memslot_delete(kvm, memslot);
}
}
@@ -501,7 +501,7 @@ unsigned long kvmppc_h_svm_init_start(struct kvm *kvm)
* from secure memory using UV_PAGE_OUT uvcall.
* Caller must held kvm->arch.uvmem_lock.
*/
-static int __kvmppc_svm_page_out(struct vm_area_struct *vma,
+static int __uvmem_svm_page_out(struct vm_area_struct *vma,
unsigned long start,
unsigned long end, unsigned long page_shift,
struct kvm *kvm, unsigned long gpa)
@@ -509,7 +509,7 @@ static int __kvmppc_svm_page_out(struct vm_area_struct *vma,
unsigned long src_pfn, dst_pfn = 0;
struct migrate_vma mig;
struct page *dpage, *spage;
- struct kvmppc_uvmem_page_pvt *pvt;
+ struct uvmem_page_pvt *pvt;
unsigned long pfn;
int ret = U_SUCCESS;
@@ -519,11 +519,11 @@ static int __kvmppc_svm_page_out(struct vm_area_struct *vma,
mig.end = end;
mig.src = &src_pfn;
mig.dst = &dst_pfn;
- mig.pgmap_owner = &kvmppc_uvmem_pgmap;
+ mig.pgmap_owner = &uvmem_pgmap;
mig.flags = MIGRATE_VMA_SELECT_DEVICE_PRIVATE;
/* The requested page is already paged-out, nothing to do */
- if (!kvmppc_gfn_is_uvmem_pfn(gpa >> page_shift, kvm, NULL))
+ if (!uvmem_gfn_is_uvmem_pfn(gpa >> page_shift, kvm, NULL))
return ret;
ret = migrate_vma_setup(&mig);
@@ -573,7 +573,7 @@ static int __kvmppc_svm_page_out(struct vm_area_struct *vma,
return ret;
}
-static inline int kvmppc_svm_page_out(struct vm_area_struct *vma,
+static inline int uvmem_svm_page_out(struct vm_area_struct *vma,
unsigned long start, unsigned long end,
unsigned long page_shift,
struct kvm *kvm, unsigned long gpa)
@@ -581,7 +581,7 @@ static inline int kvmppc_svm_page_out(struct vm_area_struct *vma,
int ret;
mutex_lock(&kvm->arch.uvmem_lock);
- ret = __kvmppc_svm_page_out(vma, start, end, page_shift, kvm, gpa);
+ ret = __uvmem_svm_page_out(vma, start, end, page_shift, kvm, gpa);
mutex_unlock(&kvm->arch.uvmem_lock);
return ret;
@@ -599,7 +599,7 @@ void kvmppc_uvmem_drop_pages(const struct kvm_memory_slot *slot,
struct kvm *kvm, bool skip_page_out)
{
int i;
- struct kvmppc_uvmem_page_pvt *pvt;
+ struct uvmem_page_pvt *pvt;
struct page *uvmem_page;
struct vm_area_struct *vma = NULL;
unsigned long uvmem_pfn, gfn;
@@ -623,19 +623,19 @@ void kvmppc_uvmem_drop_pages(const struct kvm_memory_slot *slot,
mutex_lock(&kvm->arch.uvmem_lock);
- if (kvmppc_gfn_is_uvmem_pfn(gfn, kvm, &uvmem_pfn)) {
+ if (uvmem_gfn_is_uvmem_pfn(gfn, kvm, &uvmem_pfn)) {
uvmem_page = pfn_to_page(uvmem_pfn);
pvt = uvmem_page->zone_device_data;
pvt->skip_page_out = skip_page_out;
pvt->remove_gfn = true;
- if (__kvmppc_svm_page_out(vma, addr, addr + PAGE_SIZE,
+ if (__uvmem_svm_page_out(vma, addr, addr + PAGE_SIZE,
PAGE_SHIFT, kvm, pvt->gpa))
pr_err("Can't page out gpa:0x%lx addr:0x%lx\n",
pvt->gpa, addr);
} else {
/* Remove the shared flag if any */
- kvmppc_gfn_remove(gfn, kvm);
+ uvmem_gfn_remove(gfn, kvm);
}
mutex_unlock(&kvm->arch.uvmem_lock);
@@ -680,31 +680,31 @@ unsigned long kvmppc_h_svm_init_abort(struct kvm *kvm)
*
* Called with kvm->arch.uvmem_lock held
*/
-static struct page *kvmppc_uvmem_get_page(unsigned long gpa, struct kvm *kvm)
+static struct page *uvmem_get_page(unsigned long gpa, struct kvm *kvm)
{
struct page *dpage = NULL;
unsigned long bit, uvmem_pfn;
- struct kvmppc_uvmem_page_pvt *pvt;
+ struct uvmem_page_pvt *pvt;
unsigned long pfn_last, pfn_first;
- pfn_first = kvmppc_uvmem_pgmap.res.start >> PAGE_SHIFT;
+ pfn_first = uvmem_pgmap.res.start >> PAGE_SHIFT;
pfn_last = pfn_first +
- (resource_size(&kvmppc_uvmem_pgmap.res) >> PAGE_SHIFT);
+ (resource_size(&uvmem_pgmap.res) >> PAGE_SHIFT);
- spin_lock(&kvmppc_uvmem_bitmap_lock);
- bit = find_first_zero_bit(kvmppc_uvmem_bitmap,
+ spin_lock(&uvmem_bitmap_lock);
+ bit = find_first_zero_bit(uvmem_bitmap,
pfn_last - pfn_first);
if (bit >= (pfn_last - pfn_first))
goto out;
- bitmap_set(kvmppc_uvmem_bitmap, bit, 1);
- spin_unlock(&kvmppc_uvmem_bitmap_lock);
+ bitmap_set(uvmem_bitmap, bit, 1);
+ spin_unlock(&uvmem_bitmap_lock);
pvt = kzalloc(sizeof(*pvt), GFP_KERNEL);
if (!pvt)
goto out_clear;
uvmem_pfn = bit + pfn_first;
- kvmppc_gfn_secure_uvmem_pfn(gpa >> PAGE_SHIFT, uvmem_pfn, kvm);
+ uvmem_gfn_secure_uvmem_pfn(gpa >> PAGE_SHIFT, uvmem_pfn, kvm);
pvt->gpa = gpa;
pvt->kvm = kvm;
@@ -715,10 +715,10 @@ static struct page *kvmppc_uvmem_get_page(unsigned long gpa, struct kvm *kvm)
lock_page(dpage);
return dpage;
out_clear:
- spin_lock(&kvmppc_uvmem_bitmap_lock);
- bitmap_clear(kvmppc_uvmem_bitmap, bit, 1);
+ spin_lock(&uvmem_bitmap_lock);
+ bitmap_clear(uvmem_bitmap, bit, 1);
out:
- spin_unlock(&kvmppc_uvmem_bitmap_lock);
+ spin_unlock(&uvmem_bitmap_lock);
return NULL;
}
@@ -726,7 +726,7 @@ static struct page *kvmppc_uvmem_get_page(unsigned long gpa, struct kvm *kvm)
* Alloc a PFN from private device memory pool. If @pagein is true,
* copy page from normal memory to secure memory using UV_PAGE_IN uvcall.
*/
-static int kvmppc_svm_page_in(struct vm_area_struct *vma,
+static int uvmem_svm_page_in(struct vm_area_struct *vma,
unsigned long start,
unsigned long end, unsigned long gpa, struct kvm *kvm,
unsigned long page_shift,
@@ -756,7 +756,7 @@ static int kvmppc_svm_page_in(struct vm_area_struct *vma,
goto out_finalize;
}
- dpage = kvmppc_uvmem_get_page(gpa, kvm);
+ dpage = uvmem_get_page(gpa, kvm);
if (!dpage) {
ret = -1;
goto out_finalize;
@@ -780,7 +780,7 @@ static int kvmppc_svm_page_in(struct vm_area_struct *vma,
return ret;
}
-static int kvmppc_uv_migrate_mem_slot(struct kvm *kvm,
+static int uvmem_uv_migrate_mem_slot(struct kvm *kvm,
const struct kvm_memory_slot *memslot)
{
unsigned long gfn = memslot->base_gfn;
@@ -790,7 +790,7 @@ static int kvmppc_uv_migrate_mem_slot(struct kvm *kvm,
mmap_read_lock(kvm->mm);
mutex_lock(&kvm->arch.uvmem_lock);
- while (kvmppc_next_nontransitioned_gfn(memslot, kvm, &gfn)) {
+ while (uvmem_next_nontransitioned_gfn(memslot, kvm, &gfn)) {
ret = H_STATE;
start = gfn_to_hva(kvm, gfn);
if (kvm_is_error_hva(start))
@@ -801,7 +801,7 @@ static int kvmppc_uv_migrate_mem_slot(struct kvm *kvm,
if (!vma || vma->vm_start > start || vma->vm_end < end)
break;
- ret = kvmppc_svm_page_in(vma, start, end,
+ ret = uvmem_svm_page_in(vma, start, end,
(gfn << PAGE_SHIFT), kvm, PAGE_SHIFT, false);
if (ret) {
ret = H_STATE;
@@ -830,7 +830,7 @@ unsigned long kvmppc_h_svm_init_done(struct kvm *kvm)
srcu_idx = srcu_read_lock(&kvm->srcu);
slots = kvm_memslots(kvm);
kvm_for_each_memslot(memslot, slots) {
- ret = kvmppc_uv_migrate_mem_slot(kvm, memslot);
+ ret = uvmem_uv_migrate_mem_slot(kvm, memslot);
if (ret) {
/*
* The pages will remain transitioned.
@@ -863,13 +863,13 @@ unsigned long kvmppc_h_svm_init_done(struct kvm *kvm)
* In the former case, uses dev_pagemap_ops.migrate_to_ram handler
* to unmap the device page from QEMU's page tables.
*/
-static unsigned long kvmppc_share_page(struct kvm *kvm, unsigned long gpa,
+static unsigned long uvmem_share_page(struct kvm *kvm, unsigned long gpa,
unsigned long page_shift)
{
int ret = H_PARAMETER;
struct page *uvmem_page;
- struct kvmppc_uvmem_page_pvt *pvt;
+ struct uvmem_page_pvt *pvt;
unsigned long pfn;
unsigned long gfn = gpa >> page_shift;
int srcu_idx;
@@ -877,7 +877,7 @@ static unsigned long kvmppc_share_page(struct kvm *kvm, unsigned long gpa,
srcu_idx = srcu_read_lock(&kvm->srcu);
mutex_lock(&kvm->arch.uvmem_lock);
- if (kvmppc_gfn_is_uvmem_pfn(gfn, kvm, &uvmem_pfn)) {
+ if (uvmem_gfn_is_uvmem_pfn(gfn, kvm, &uvmem_pfn)) {
uvmem_page = pfn_to_page(uvmem_pfn);
pvt = uvmem_page->zone_device_data;
pvt->skip_page_out = true;
@@ -895,7 +895,7 @@ static unsigned long kvmppc_share_page(struct kvm *kvm, unsigned long gpa,
goto out;
mutex_lock(&kvm->arch.uvmem_lock);
- if (kvmppc_gfn_is_uvmem_pfn(gfn, kvm, &uvmem_pfn)) {
+ if (uvmem_gfn_is_uvmem_pfn(gfn, kvm, &uvmem_pfn)) {
uvmem_page = pfn_to_page(uvmem_pfn);
pvt = uvmem_page->zone_device_data;
pvt->skip_page_out = true;
@@ -906,7 +906,7 @@ static unsigned long kvmppc_share_page(struct kvm *kvm, unsigned long gpa,
if (!uv_page_in(kvm->arch.lpid, pfn << page_shift, gpa, 0,
page_shift)) {
- kvmppc_gfn_shared(gfn, kvm);
+ uvmem_gfn_shared(gfn, kvm);
ret = H_SUCCESS;
}
kvm_release_pfn_clean(pfn);
@@ -942,7 +942,7 @@ unsigned long kvmppc_h_svm_page_in(struct kvm *kvm, unsigned long gpa,
return H_P2;
if (flags & H_PAGE_IN_SHARED)
- return kvmppc_share_page(kvm, gpa, page_shift);
+ return uvmem_share_page(kvm, gpa, page_shift);
ret = H_PARAMETER;
srcu_idx = srcu_read_lock(&kvm->srcu);
@@ -954,7 +954,7 @@ unsigned long kvmppc_h_svm_page_in(struct kvm *kvm, unsigned long gpa,
mutex_lock(&kvm->arch.uvmem_lock);
/* Fail the page-in request of an already paged-in page */
- if (kvmppc_gfn_is_uvmem_pfn(gfn, kvm, NULL))
+ if (uvmem_gfn_is_uvmem_pfn(gfn, kvm, NULL))
goto out_unlock;
end = start + (1UL << page_shift);
@@ -962,7 +962,7 @@ unsigned long kvmppc_h_svm_page_in(struct kvm *kvm, unsigned long gpa,
if (!vma || vma->vm_start > start || vma->vm_end < end)
goto out_unlock;
- if (kvmppc_svm_page_in(vma, start, end, gpa, kvm, page_shift,
+ if (uvmem_svm_page_in(vma, start, end, gpa, kvm, page_shift,
true))
goto out_unlock;
@@ -987,9 +987,9 @@ unsigned long kvmppc_h_svm_page_in(struct kvm *kvm, unsigned long gpa,
*/
static vm_fault_t kvmppc_uvmem_migrate_to_ram(struct vm_fault *vmf)
{
- struct kvmppc_uvmem_page_pvt *pvt = vmf->page->zone_device_data;
+ struct uvmem_page_pvt *pvt = vmf->page->zone_device_data;
- if (kvmppc_svm_page_out(vmf->vma, vmf->address,
+ if (uvmem_svm_page_out(vmf->vma, vmf->address,
vmf->address + PAGE_SIZE, PAGE_SHIFT,
pvt->kvm, pvt->gpa))
return VM_FAULT_SIGBUS;
@@ -1007,23 +1007,23 @@ static vm_fault_t kvmppc_uvmem_migrate_to_ram(struct vm_fault *vmf)
static void kvmppc_uvmem_page_free(struct page *page)
{
unsigned long pfn = page_to_pfn(page) -
- (kvmppc_uvmem_pgmap.res.start >> PAGE_SHIFT);
- struct kvmppc_uvmem_page_pvt *pvt;
+ (uvmem_pgmap.res.start >> PAGE_SHIFT);
+ struct uvmem_page_pvt *pvt;
- spin_lock(&kvmppc_uvmem_bitmap_lock);
- bitmap_clear(kvmppc_uvmem_bitmap, pfn, 1);
- spin_unlock(&kvmppc_uvmem_bitmap_lock);
+ spin_lock(&uvmem_bitmap_lock);
+ bitmap_clear(uvmem_bitmap, pfn, 1);
+ spin_unlock(&uvmem_bitmap_lock);
pvt = page->zone_device_data;
page->zone_device_data = NULL;
if (pvt->remove_gfn)
- kvmppc_gfn_remove(pvt->gpa >> PAGE_SHIFT, pvt->kvm);
+ uvmem_gfn_remove(pvt->gpa >> PAGE_SHIFT, pvt->kvm);
else
- kvmppc_gfn_secure_mem_pfn(pvt->gpa >> PAGE_SHIFT, pvt->kvm);
+ uvmem_gfn_secure_mem_pfn(pvt->gpa >> PAGE_SHIFT, pvt->kvm);
kfree(pvt);
}
-static const struct dev_pagemap_ops kvmppc_uvmem_ops = {
+static const struct dev_pagemap_ops uvmem_ops = {
.page_free = kvmppc_uvmem_page_free,
.migrate_to_ram = kvmppc_uvmem_migrate_to_ram,
};
@@ -1062,7 +1062,7 @@ static void kvmppc_uvmem_page_free(struct page *page)
if (!vma || vma->vm_start > start || vma->vm_end < end)
goto out;
- if (!kvmppc_svm_page_out(vma, start, end, page_shift, kvm, gpa))
+ if (!uvmem_svm_page_out(vma, start, end, page_shift, kvm, gpa))
ret = H_SUCCESS;
out:
mmap_read_unlock(kvm->mm);
@@ -1080,7 +1080,7 @@ int kvmppc_send_page_to_uv(struct kvm *kvm, unsigned long gfn)
return -EFAULT;
mutex_lock(&kvm->arch.uvmem_lock);
- if (kvmppc_gfn_is_uvmem_pfn(gfn, kvm, NULL))
+ if (uvmem_gfn_is_uvmem_pfn(gfn, kvm, NULL))
goto out;
ret = uv_page_in(kvm->arch.lpid, pfn << PAGE_SHIFT, gfn << PAGE_SHIFT,
@@ -1093,20 +1093,20 @@ int kvmppc_send_page_to_uv(struct kvm *kvm, unsigned long gfn)
int kvmppc_uvmem_memslot_create(struct kvm *kvm, const struct kvm_memory_slot *new)
{
- int ret = __kvmppc_uvmem_memslot_create(kvm, new);
+ int ret = __uvmem_memslot_create(kvm, new);
if (!ret)
- ret = kvmppc_uv_migrate_mem_slot(kvm, new);
+ ret = uvmem_uv_migrate_mem_slot(kvm, new);
return ret;
}
void kvmppc_uvmem_memslot_delete(struct kvm *kvm, const struct kvm_memory_slot *old)
{
- __kvmppc_uvmem_memslot_delete(kvm, old);
+ __uvmem_memslot_delete(kvm, old);
}
-static u64 kvmppc_get_secmem_size(void)
+static u64 uvmem_get_secmem_size(void)
{
struct device_node *np;
int i, len;
@@ -1152,7 +1152,7 @@ int kvmppc_uvmem_init(void)
void *addr;
unsigned long pfn_last, pfn_first;
- size = kvmppc_get_secmem_size();
+ size = uvmem_get_secmem_size();
if (!size) {
/*
* Don't fail the initialization of kvm-hv module if
@@ -1163,18 +1163,18 @@ int kvmppc_uvmem_init(void)
goto out;
}
- res = request_free_mem_region(&iomem_resource, size, "kvmppc_uvmem");
+ res = request_free_mem_region(&iomem_resource, size, "uvmem");
if (IS_ERR(res)) {
ret = PTR_ERR(res);
goto out;
}
- kvmppc_uvmem_pgmap.type = MEMORY_DEVICE_PRIVATE;
- kvmppc_uvmem_pgmap.res = *res;
- kvmppc_uvmem_pgmap.ops = &kvmppc_uvmem_ops;
+ uvmem_pgmap.type = MEMORY_DEVICE_PRIVATE;
+ uvmem_pgmap.res = *res;
+ uvmem_pgmap.ops = &uvmem_ops;
/* just one global instance: */
- kvmppc_uvmem_pgmap.owner = &kvmppc_uvmem_pgmap;
- addr = memremap_pages(&kvmppc_uvmem_pgmap, NUMA_NO_NODE);
+ uvmem_pgmap.owner = &uvmem_pgmap;
+ addr = memremap_pages(&uvmem_pgmap, NUMA_NO_NODE);
if (IS_ERR(addr)) {
ret = PTR_ERR(addr);
goto out_free_region;
@@ -1182,9 +1182,9 @@ int kvmppc_uvmem_init(void)
pfn_first = res->start >> PAGE_SHIFT;
pfn_last = pfn_first + (resource_size(res) >> PAGE_SHIFT);
- kvmppc_uvmem_bitmap = kcalloc(BITS_TO_LONGS(pfn_last - pfn_first),
+ uvmem_bitmap = kcalloc(BITS_TO_LONGS(pfn_last - pfn_first),
sizeof(unsigned long), GFP_KERNEL);
- if (!kvmppc_uvmem_bitmap) {
+ if (!uvmem_bitmap) {
ret = -ENOMEM;
goto out_unmap;
}
@@ -1192,7 +1192,7 @@ int kvmppc_uvmem_init(void)
pr_info("KVMPPC-UVMEM: Secure Memory size 0x%lx\n", size);
return ret;
out_unmap:
- memunmap_pages(&kvmppc_uvmem_pgmap);
+ memunmap_pages(&uvmem_pgmap);
out_free_region:
release_mem_region(res->start, size);
out:
@@ -1201,11 +1201,11 @@ int kvmppc_uvmem_init(void)
void kvmppc_uvmem_free(void)
{
- if (!kvmppc_uvmem_bitmap)
+ if (!uvmem_bitmap)
return;
- memunmap_pages(&kvmppc_uvmem_pgmap);
- release_mem_region(kvmppc_uvmem_pgmap.res.start,
- resource_size(&kvmppc_uvmem_pgmap.res));
- kfree(kvmppc_uvmem_bitmap);
+ memunmap_pages(&uvmem_pgmap);
+ release_mem_region(uvmem_pgmap.res.start,
+ resource_size(&uvmem_pgmap.res));
+ kfree(uvmem_bitmap);
}
--
1.8.3.1
More information about the Linuxppc-dev
mailing list