forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
296 lines
7.8 KiB
296 lines
7.8 KiB
/* |
|
* MMU operations common to all auto-translated physmap guests. |
|
* |
|
* Copyright (C) 2015 Citrix Systems R&D Ltd. |
|
* |
|
* This program is free software; you can redistribute it and/or |
|
* modify it under the terms of the GNU General Public License version 2 |
|
* as published by the Free Software Foundation; or, when distributed |
|
* separately from the Linux kernel or incorporated into other |
|
* software packages, subject to the following license: |
|
* |
|
* Permission is hereby granted, free of charge, to any person obtaining a copy |
|
* of this source file (the "Software"), to deal in the Software without |
|
* restriction, including without limitation the rights to use, copy, modify, |
|
* merge, publish, distribute, sublicense, and/or sell copies of the Software, |
|
* and to permit persons to whom the Software is furnished to do so, subject to |
|
* the following conditions: |
|
* |
|
* The above copyright notice and this permission notice shall be included in |
|
* all copies or substantial portions of the Software. |
|
* |
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
|
* IN THE SOFTWARE. |
|
*/ |
|
#include <linux/kernel.h> |
|
#include <linux/mm.h> |
|
#include <linux/slab.h> |
|
#include <linux/vmalloc.h> |
|
|
|
#include <asm/xen/hypercall.h> |
|
#include <asm/xen/hypervisor.h> |
|
|
|
#include <xen/xen.h> |
|
#include <xen/xen-ops.h> |
|
#include <xen/page.h> |
|
#include <xen/interface/xen.h> |
|
#include <xen/interface/memory.h> |
|
#include <xen/balloon.h> |
|
|
|
typedef void (*xen_gfn_fn_t)(unsigned long gfn, void *data); |
|
|
|
/* Break down the pages in 4KB chunk and call fn for each gfn */ |
|
static void xen_for_each_gfn(struct page **pages, unsigned nr_gfn, |
|
xen_gfn_fn_t fn, void *data) |
|
{ |
|
unsigned long xen_pfn = 0; |
|
struct page *page; |
|
int i; |
|
|
|
for (i = 0; i < nr_gfn; i++) { |
|
if ((i % XEN_PFN_PER_PAGE) == 0) { |
|
page = pages[i / XEN_PFN_PER_PAGE]; |
|
xen_pfn = page_to_xen_pfn(page); |
|
} |
|
fn(pfn_to_gfn(xen_pfn++), data); |
|
} |
|
} |
|
|
|
struct remap_data { |
|
xen_pfn_t *fgfn; /* foreign domain's gfn */ |
|
int nr_fgfn; /* Number of foreign gfn left to map */ |
|
pgprot_t prot; |
|
domid_t domid; |
|
struct vm_area_struct *vma; |
|
int index; |
|
struct page **pages; |
|
struct xen_remap_gfn_info *info; |
|
int *err_ptr; |
|
int mapped; |
|
|
|
/* Hypercall parameters */ |
|
int h_errs[XEN_PFN_PER_PAGE]; |
|
xen_ulong_t h_idxs[XEN_PFN_PER_PAGE]; |
|
xen_pfn_t h_gpfns[XEN_PFN_PER_PAGE]; |
|
|
|
int h_iter; /* Iterator */ |
|
}; |
|
|
|
static void setup_hparams(unsigned long gfn, void *data) |
|
{ |
|
struct remap_data *info = data; |
|
|
|
info->h_idxs[info->h_iter] = *info->fgfn; |
|
info->h_gpfns[info->h_iter] = gfn; |
|
info->h_errs[info->h_iter] = 0; |
|
|
|
info->h_iter++; |
|
info->fgfn++; |
|
} |
|
|
|
static int remap_pte_fn(pte_t *ptep, unsigned long addr, void *data) |
|
{ |
|
struct remap_data *info = data; |
|
struct page *page = info->pages[info->index++]; |
|
pte_t pte = pte_mkspecial(pfn_pte(page_to_pfn(page), info->prot)); |
|
int rc, nr_gfn; |
|
uint32_t i; |
|
struct xen_add_to_physmap_range xatp = { |
|
.domid = DOMID_SELF, |
|
.foreign_domid = info->domid, |
|
.space = XENMAPSPACE_gmfn_foreign, |
|
}; |
|
|
|
nr_gfn = min_t(typeof(info->nr_fgfn), XEN_PFN_PER_PAGE, info->nr_fgfn); |
|
info->nr_fgfn -= nr_gfn; |
|
|
|
info->h_iter = 0; |
|
xen_for_each_gfn(&page, nr_gfn, setup_hparams, info); |
|
BUG_ON(info->h_iter != nr_gfn); |
|
|
|
set_xen_guest_handle(xatp.idxs, info->h_idxs); |
|
set_xen_guest_handle(xatp.gpfns, info->h_gpfns); |
|
set_xen_guest_handle(xatp.errs, info->h_errs); |
|
xatp.size = nr_gfn; |
|
|
|
rc = HYPERVISOR_memory_op(XENMEM_add_to_physmap_range, &xatp); |
|
|
|
/* info->err_ptr expect to have one error status per Xen PFN */ |
|
for (i = 0; i < nr_gfn; i++) { |
|
int err = (rc < 0) ? rc : info->h_errs[i]; |
|
|
|
*(info->err_ptr++) = err; |
|
if (!err) |
|
info->mapped++; |
|
} |
|
|
|
/* |
|
* Note: The hypercall will return 0 in most of the case if even if |
|
* all the fgmfn are not mapped. We still have to update the pte |
|
* as the userspace may decide to continue. |
|
*/ |
|
if (!rc) |
|
set_pte_at(info->vma->vm_mm, addr, ptep, pte); |
|
|
|
return 0; |
|
} |
|
|
|
int xen_xlate_remap_gfn_array(struct vm_area_struct *vma, |
|
unsigned long addr, |
|
xen_pfn_t *gfn, int nr, |
|
int *err_ptr, pgprot_t prot, |
|
unsigned domid, |
|
struct page **pages) |
|
{ |
|
int err; |
|
struct remap_data data; |
|
unsigned long range = DIV_ROUND_UP(nr, XEN_PFN_PER_PAGE) << PAGE_SHIFT; |
|
|
|
/* Kept here for the purpose of making sure code doesn't break |
|
x86 PVOPS */ |
|
BUG_ON(!((vma->vm_flags & (VM_PFNMAP | VM_IO)) == (VM_PFNMAP | VM_IO))); |
|
|
|
data.fgfn = gfn; |
|
data.nr_fgfn = nr; |
|
data.prot = prot; |
|
data.domid = domid; |
|
data.vma = vma; |
|
data.pages = pages; |
|
data.index = 0; |
|
data.err_ptr = err_ptr; |
|
data.mapped = 0; |
|
|
|
err = apply_to_page_range(vma->vm_mm, addr, range, |
|
remap_pte_fn, &data); |
|
return err < 0 ? err : data.mapped; |
|
} |
|
EXPORT_SYMBOL_GPL(xen_xlate_remap_gfn_array); |
|
|
|
static void unmap_gfn(unsigned long gfn, void *data) |
|
{ |
|
struct xen_remove_from_physmap xrp; |
|
|
|
xrp.domid = DOMID_SELF; |
|
xrp.gpfn = gfn; |
|
(void)HYPERVISOR_memory_op(XENMEM_remove_from_physmap, &xrp); |
|
} |
|
|
|
int xen_xlate_unmap_gfn_range(struct vm_area_struct *vma, |
|
int nr, struct page **pages) |
|
{ |
|
xen_for_each_gfn(pages, nr, unmap_gfn, NULL); |
|
|
|
return 0; |
|
} |
|
EXPORT_SYMBOL_GPL(xen_xlate_unmap_gfn_range); |
|
|
|
struct map_balloon_pages { |
|
xen_pfn_t *pfns; |
|
unsigned int idx; |
|
}; |
|
|
|
static void setup_balloon_gfn(unsigned long gfn, void *data) |
|
{ |
|
struct map_balloon_pages *info = data; |
|
|
|
info->pfns[info->idx++] = gfn; |
|
} |
|
|
|
/** |
|
* xen_xlate_map_ballooned_pages - map a new set of ballooned pages |
|
* @gfns: returns the array of corresponding GFNs |
|
* @virt: returns the virtual address of the mapped region |
|
* @nr_grant_frames: number of GFNs |
|
* @return 0 on success, error otherwise |
|
* |
|
* This allocates a set of ballooned pages and maps them into the |
|
* kernel's address space. |
|
*/ |
|
int __init xen_xlate_map_ballooned_pages(xen_pfn_t **gfns, void **virt, |
|
unsigned long nr_grant_frames) |
|
{ |
|
struct page **pages; |
|
xen_pfn_t *pfns; |
|
void *vaddr; |
|
struct map_balloon_pages data; |
|
int rc; |
|
unsigned long nr_pages; |
|
|
|
BUG_ON(nr_grant_frames == 0); |
|
nr_pages = DIV_ROUND_UP(nr_grant_frames, XEN_PFN_PER_PAGE); |
|
pages = kcalloc(nr_pages, sizeof(pages[0]), GFP_KERNEL); |
|
if (!pages) |
|
return -ENOMEM; |
|
|
|
pfns = kcalloc(nr_grant_frames, sizeof(pfns[0]), GFP_KERNEL); |
|
if (!pfns) { |
|
kfree(pages); |
|
return -ENOMEM; |
|
} |
|
rc = xen_alloc_unpopulated_pages(nr_pages, pages); |
|
if (rc) { |
|
pr_warn("%s Couldn't balloon alloc %ld pages rc:%d\n", __func__, |
|
nr_pages, rc); |
|
kfree(pages); |
|
kfree(pfns); |
|
return rc; |
|
} |
|
|
|
data.pfns = pfns; |
|
data.idx = 0; |
|
xen_for_each_gfn(pages, nr_grant_frames, setup_balloon_gfn, &data); |
|
|
|
vaddr = vmap(pages, nr_pages, 0, PAGE_KERNEL); |
|
if (!vaddr) { |
|
pr_warn("%s Couldn't map %ld pages rc:%d\n", __func__, |
|
nr_pages, rc); |
|
xen_free_unpopulated_pages(nr_pages, pages); |
|
kfree(pages); |
|
kfree(pfns); |
|
return -ENOMEM; |
|
} |
|
kfree(pages); |
|
|
|
*gfns = pfns; |
|
*virt = vaddr; |
|
|
|
return 0; |
|
} |
|
EXPORT_SYMBOL_GPL(xen_xlate_map_ballooned_pages); |
|
|
|
struct remap_pfn { |
|
struct mm_struct *mm; |
|
struct page **pages; |
|
pgprot_t prot; |
|
unsigned long i; |
|
}; |
|
|
|
static int remap_pfn_fn(pte_t *ptep, unsigned long addr, void *data) |
|
{ |
|
struct remap_pfn *r = data; |
|
struct page *page = r->pages[r->i]; |
|
pte_t pte = pte_mkspecial(pfn_pte(page_to_pfn(page), r->prot)); |
|
|
|
set_pte_at(r->mm, addr, ptep, pte); |
|
r->i++; |
|
|
|
return 0; |
|
} |
|
|
|
/* Used by the privcmd module, but has to be built-in on ARM */ |
|
int xen_remap_vma_range(struct vm_area_struct *vma, unsigned long addr, unsigned long len) |
|
{ |
|
struct remap_pfn r = { |
|
.mm = vma->vm_mm, |
|
.pages = vma->vm_private_data, |
|
.prot = vma->vm_page_prot, |
|
}; |
|
|
|
return apply_to_page_range(vma->vm_mm, addr, len, remap_pfn_fn, &r); |
|
} |
|
EXPORT_SYMBOL_GPL(xen_remap_vma_range);
|
|
|