[linux-2.6-block.git] / drivers / xen / xlate_mmu.c

/*
 * 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, pgtable_t token, 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 = alloc_xenballooned_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);
		free_xenballooned_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);
Commit	Line	Data
628c28ee DV	1	/*
	2	* MMU operations common to all auto-translated physmap guests.
	3	*
	4	* Copyright (C) 2015 Citrix Systems R&D Ltd.
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License version 2
	8	* as published by the Free Software Foundation; or, when distributed
	9	* separately from the Linux kernel or incorporated into other
	10	* software packages, subject to the following license:
	11	*
	12	* Permission is hereby granted, free of charge, to any person obtaining a copy
	13	* of this source file (the "Software"), to deal in the Software without
	14	* restriction, including without limitation the rights to use, copy, modify,
	15	* merge, publish, distribute, sublicense, and/or sell copies of the Software,
	16	* and to permit persons to whom the Software is furnished to do so, subject to
	17	* the following conditions:
	18	*
	19	* The above copyright notice and this permission notice shall be included in
	20	* all copies or substantial portions of the Software.
	21	*
	22	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	23	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	24	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	25	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	26	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	27	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
	28	* IN THE SOFTWARE.
	29	*/
	30	#include <linux/kernel.h>
	31	#include <linux/mm.h>
243848fc SZ	32	#include <linux/slab.h>
243848fc SZ	33	#include <linux/vmalloc.h>
628c28ee DV	34
	35	#include <asm/xen/hypercall.h>
	36	#include <asm/xen/hypervisor.h>
	37
	38	#include <xen/xen.h>
72791ac8	39	#include <xen/xen-ops.h>
628c28ee DV	40	#include <xen/page.h>
	41	#include <xen/interface/xen.h>
	42	#include <xen/interface/memory.h>
243848fc	43	#include <xen/balloon.h>
628c28ee	44
5995a68a	45	typedef void (xen_gfn_fn_t)(unsigned long gfn, void data);
628c28ee	46
5995a68a JG	47	/* Break down the pages in 4KB chunk and call fn for each gfn */
	48	static void xen_for_each_gfn(struct page **pages, unsigned nr_gfn,
	49	xen_gfn_fn_t fn, void *data)
	50	{
	51	unsigned long xen_pfn = 0;
	52	struct page *page;
	53	int i;
628c28ee	54
5995a68a JG	55	for (i = 0; i < nr_gfn; i++) {
	56	if ((i % XEN_PFN_PER_PAGE) == 0) {
	57	page = pages[i / XEN_PFN_PER_PAGE];
	58	xen_pfn = page_to_xen_pfn(page);
	59	}
	60	fn(pfn_to_gfn(xen_pfn++), data);
	61	}
628c28ee DV	62	}
	63
	64	struct remap_data {
a13d7201	65	xen_pfn_t fgfn; / foreign domain's gfn */
5995a68a	66	int nr_fgfn; /* Number of foreign gfn left to map */
628c28ee DV	67	pgprot_t prot;
	68	domid_t domid;
	69	struct vm_area_struct *vma;
	70	int index;
	71	struct page **pages;
a13d7201	72	struct xen_remap_gfn_info *info;
4e8c0c8c DV	73	int *err_ptr;
4e8c0c8c DV	74	int mapped;
5995a68a JG	75
	76	/* Hypercall parameters */
	77	int h_errs[XEN_PFN_PER_PAGE];
	78	xen_ulong_t h_idxs[XEN_PFN_PER_PAGE];
	79	xen_pfn_t h_gpfns[XEN_PFN_PER_PAGE];
	80
	81	int h_iter; /* Iterator */
628c28ee DV	82	};
628c28ee DV	83
5995a68a JG	84	static void setup_hparams(unsigned long gfn, void *data)
	85	{
	86	struct remap_data *info = data;
	87
	88	info->h_idxs[info->h_iter] = *info->fgfn;
	89	info->h_gpfns[info->h_iter] = gfn;
	90	info->h_errs[info->h_iter] = 0;
	91
	92	info->h_iter++;
	93	info->fgfn++;
	94	}
	95
628c28ee DV	96	static int remap_pte_fn(pte_t *ptep, pgtable_t token, unsigned long addr,
	97	void *data)
	98	{
	99	struct remap_data *info = data;
	100	struct page *page = info->pages[info->index++];
5995a68a JG	101	pte_t pte = pte_mkspecial(pfn_pte(page_to_pfn(page), info->prot));
	102	int rc, nr_gfn;
	103	uint32_t i;
	104	struct xen_add_to_physmap_range xatp = {
	105	.domid = DOMID_SELF,
	106	.foreign_domid = info->domid,
	107	.space = XENMAPSPACE_gmfn_foreign,
	108	};
628c28ee	109
5995a68a JG	110	nr_gfn = min_t(typeof(info->nr_fgfn), XEN_PFN_PER_PAGE, info->nr_fgfn);
	111	info->nr_fgfn -= nr_gfn;
	112
	113	info->h_iter = 0;
	114	xen_for_each_gfn(&page, nr_gfn, setup_hparams, info);
	115	BUG_ON(info->h_iter != nr_gfn);
	116
	117	set_xen_guest_handle(xatp.idxs, info->h_idxs);
	118	set_xen_guest_handle(xatp.gpfns, info->h_gpfns);
	119	set_xen_guest_handle(xatp.errs, info->h_errs);
	120	xatp.size = nr_gfn;
	121
	122	rc = HYPERVISOR_memory_op(XENMEM_add_to_physmap_range, &xatp);
	123
	124	/* info->err_ptr expect to have one error status per Xen PFN */
	125	for (i = 0; i < nr_gfn; i++) {
	126	int err = (rc < 0) ? rc : info->h_errs[i];
	127
	128	*(info->err_ptr++) = err;
	129	if (!err)
	130	info->mapped++;
4e8c0c8c	131	}
5995a68a JG	132
	133	/*
	134	* Note: The hypercall will return 0 in most of the case if even if
	135	* all the fgmfn are not mapped. We still have to update the pte
	136	* as the userspace may decide to continue.
	137	*/
	138	if (!rc)
	139	set_pte_at(info->vma->vm_mm, addr, ptep, pte);
628c28ee DV	140
	141	return 0;
	142	}
	143
4e8c0c8c	144	int xen_xlate_remap_gfn_array(struct vm_area_struct *vma,
628c28ee	145	unsigned long addr,
a13d7201	146	xen_pfn_t *gfn, int nr,
4e8c0c8c DV	147	int *err_ptr, pgprot_t prot,
4e8c0c8c DV	148	unsigned domid,
628c28ee DV	149	struct page **pages)
	150	{
	151	int err;
	152	struct remap_data data;
5995a68a	153	unsigned long range = DIV_ROUND_UP(nr, XEN_PFN_PER_PAGE) << PAGE_SHIFT;
628c28ee	154
4e8c0c8c DV	155	/* Kept here for the purpose of making sure code doesn't break
	156	x86 PVOPS */
	157	BUG_ON(!((vma->vm_flags & (VM_PFNMAP \| VM_IO)) == (VM_PFNMAP \| VM_IO)));
628c28ee	158
a13d7201	159	data.fgfn = gfn;
5995a68a	160	data.nr_fgfn = nr;
4e8c0c8c	161	data.prot = prot;
628c28ee	162	data.domid = domid;
4e8c0c8c	163	data.vma = vma;
628c28ee	164	data.pages = pages;
4e8c0c8c DV	165	data.index = 0;
	166	data.err_ptr = err_ptr;
	167	data.mapped = 0;
	168
	169	err = apply_to_page_range(vma->vm_mm, addr, range,
628c28ee	170	remap_pte_fn, &data);
4e8c0c8c	171	return err < 0 ? err : data.mapped;
628c28ee	172	}
4e8c0c8c	173	EXPORT_SYMBOL_GPL(xen_xlate_remap_gfn_array);
628c28ee	174
5995a68a	175	static void unmap_gfn(unsigned long gfn, void *data)
628c28ee	176	{
5995a68a	177	struct xen_remove_from_physmap xrp;
628c28ee	178
5995a68a JG	179	xrp.domid = DOMID_SELF;
	180	xrp.gpfn = gfn;
	181	(void)HYPERVISOR_memory_op(XENMEM_remove_from_physmap, &xrp);
	182	}
628c28ee	183
5995a68a JG	184	int xen_xlate_unmap_gfn_range(struct vm_area_struct *vma,
	185	int nr, struct page **pages)
	186	{
	187	xen_for_each_gfn(pages, nr, unmap_gfn, NULL);
628c28ee	188
628c28ee DV	189	return 0;
	190	}
	191	EXPORT_SYMBOL_GPL(xen_xlate_unmap_gfn_range);
243848fc	192
975fac3c SZ	193	struct map_balloon_pages {
	194	xen_pfn_t *pfns;
	195	unsigned int idx;
	196	};
	197
	198	static void setup_balloon_gfn(unsigned long gfn, void *data)
	199	{
	200	struct map_balloon_pages *info = data;
	201
	202	info->pfns[info->idx++] = gfn;
	203	}
	204
243848fc SZ	205	/**
	206	* xen_xlate_map_ballooned_pages - map a new set of ballooned pages
	207	* @gfns: returns the array of corresponding GFNs
	208	* @virt: returns the virtual address of the mapped region
	209	* @nr_grant_frames: number of GFNs
	210	* @return 0 on success, error otherwise
	211	*
	212	* This allocates a set of ballooned pages and maps them into the
	213	* kernel's address space.
	214	*/
	215	int __init xen_xlate_map_ballooned_pages(xen_pfn_t gfns, void virt,
	216	unsigned long nr_grant_frames)
	217	{
	218	struct page **pages;
	219	xen_pfn_t *pfns;
	220	void *vaddr;
975fac3c	221	struct map_balloon_pages data;
243848fc	222	int rc;
975fac3c	223	unsigned long nr_pages;
243848fc SZ	224
243848fc SZ	225	BUG_ON(nr_grant_frames == 0);
975fac3c SZ	226	nr_pages = DIV_ROUND_UP(nr_grant_frames, XEN_PFN_PER_PAGE);
975fac3c SZ	227	pages = kcalloc(nr_pages, sizeof(pages[0]), GFP_KERNEL);
243848fc SZ	228	if (!pages)
	229	return -ENOMEM;
	230
	231	pfns = kcalloc(nr_grant_frames, sizeof(pfns[0]), GFP_KERNEL);
	232	if (!pfns) {
	233	kfree(pages);
	234	return -ENOMEM;
	235	}
975fac3c	236	rc = alloc_xenballooned_pages(nr_pages, pages);
243848fc	237	if (rc) {
975fac3c SZ	238	pr_warn("%s Couldn't balloon alloc %ld pages rc:%d\n", __func__,
975fac3c SZ	239	nr_pages, rc);
243848fc SZ	240	kfree(pages);
	241	kfree(pfns);
	242	return rc;
	243	}
243848fc	244
975fac3c SZ	245	data.pfns = pfns;
	246	data.idx = 0;
	247	xen_for_each_gfn(pages, nr_grant_frames, setup_balloon_gfn, &data);
	248
	249	vaddr = vmap(pages, nr_pages, 0, PAGE_KERNEL);
243848fc	250	if (!vaddr) {
975fac3c SZ	251	pr_warn("%s Couldn't map %ld pages rc:%d\n", __func__,
	252	nr_pages, rc);
	253	free_xenballooned_pages(nr_pages, pages);
243848fc SZ	254	kfree(pages);
	255	kfree(pfns);
	256	return -ENOMEM;
	257	}
	258	kfree(pages);
	259
	260	*gfns = pfns;
	261	*virt = vaddr;
	262
	263	return 0;
	264	}
	265	EXPORT_SYMBOL_GPL(xen_xlate_map_ballooned_pages);