[linux-2.6-block.git] / arch / x86 / xen / grant-table.c

/******************************************************************************
 * grant_table.c
 * x86 specific part
 *
 * Granting foreign access to our memory reservation.
 *
 * Copyright (c) 2005-2006, Christopher Clark
 * Copyright (c) 2004-2005, K A Fraser
 * Copyright (c) 2008 Isaku Yamahata <yamahata at valinux co jp>
 *                    VA Linux Systems Japan. Split out x86 specific part.
 *
 * 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/sched.h>
#include <linux/mm.h>
#include <linux/vmalloc.h>

#include <xen/interface/xen.h>
#include <xen/page.h>
#include <xen/grant_table.h>

#include <asm/pgtable.h>

static int map_pte_fn(pte_t *pte, struct page *pmd_page,
		      unsigned long addr, void *data)
{
	unsigned long **frames = (unsigned long **)data;

	set_pte_at(&init_mm, addr, pte, mfn_pte((*frames)[0], PAGE_KERNEL));
	(*frames)++;
	return 0;
}

/*
 * This function is used to map shared frames to store grant status. It is
 * different from map_pte_fn above, the frames type here is uint64_t.
 */
static int map_pte_fn_status(pte_t *pte, struct page *pmd_page,
			     unsigned long addr, void *data)
{
	uint64_t **frames = (uint64_t **)data;

	set_pte_at(&init_mm, addr, pte, mfn_pte((*frames)[0], PAGE_KERNEL));
	(*frames)++;
	return 0;
}

static int unmap_pte_fn(pte_t *pte, struct page *pmd_page,
			unsigned long addr, void *data)
{

	set_pte_at(&init_mm, addr, pte, __pte(0));
	return 0;
}

int arch_gnttab_map_shared(unsigned long *frames, unsigned long nr_gframes,
			   unsigned long max_nr_gframes,
			   void **__shared)
{
	int rc;
	void *shared = *__shared;

	if (shared == NULL) {
		struct vm_struct *area =
			alloc_vm_area(PAGE_SIZE * max_nr_gframes, NULL);
		BUG_ON(area == NULL);
		shared = area->addr;
		*__shared = shared;
	}

	rc = apply_to_page_range(&init_mm, (unsigned long)shared,
				 PAGE_SIZE * nr_gframes,
				 map_pte_fn, &frames);
	return rc;
}

int arch_gnttab_map_status(uint64_t *frames, unsigned long nr_gframes,
			   unsigned long max_nr_gframes,
			   grant_status_t **__shared)
{
	int rc;
	grant_status_t *shared = *__shared;

	if (shared == NULL) {
		/* No need to pass in PTE as we are going to do it
		 * in apply_to_page_range anyhow. */
		struct vm_struct *area =
			alloc_vm_area(PAGE_SIZE * max_nr_gframes, NULL);
		BUG_ON(area == NULL);
		shared = area->addr;
		*__shared = shared;
	}

	rc = apply_to_page_range(&init_mm, (unsigned long)shared,
				 PAGE_SIZE * nr_gframes,
				 map_pte_fn_status, &frames);
	return rc;
}

void arch_gnttab_unmap(void *shared, unsigned long nr_gframes)
{
	apply_to_page_range(&init_mm, (unsigned long)shared,
			    PAGE_SIZE * nr_gframes, unmap_pte_fn, NULL);
}
#ifdef CONFIG_XEN_PVH
#include <xen/balloon.h>
#include <xen/events.h>
#include <xen/xen.h>
#include <linux/slab.h>
static int __init xlated_setup_gnttab_pages(void)
{
	struct page **pages;
	xen_pfn_t *pfns;
	int rc;
	unsigned int i;
	unsigned long nr_grant_frames = gnttab_max_grant_frames();

	BUG_ON(nr_grant_frames == 0);
	pages = kcalloc(nr_grant_frames, 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_grant_frames, pages, 0 /* lowmem */);
	if (rc) {
		pr_warn("%s Couldn't balloon alloc %ld pfns rc:%d\n", __func__,
			nr_grant_frames, rc);
		kfree(pages);
		kfree(pfns);
		return rc;
	}
	for (i = 0; i < nr_grant_frames; i++)
		pfns[i] = page_to_pfn(pages[i]);

	rc = arch_gnttab_map_shared(pfns, nr_grant_frames, nr_grant_frames,
				    &xen_auto_xlat_grant_frames.vaddr);

	if (rc) {
		pr_warn("%s Couldn't map %ld pfns rc:%d\n", __func__,
			nr_grant_frames, rc);
		free_xenballooned_pages(nr_grant_frames, pages);
		kfree(pages);
		kfree(pfns);
		return rc;
	}
	kfree(pages);

	xen_auto_xlat_grant_frames.pfn = pfns;
	xen_auto_xlat_grant_frames.count = nr_grant_frames;

	return 0;
}

static int __init xen_pvh_gnttab_setup(void)
{
	if (!xen_pvh_domain())
		return -ENODEV;

	return xlated_setup_gnttab_pages();
}
/* Call it _before_ __gnttab_init as we need to initialize the
 * xen_auto_xlat_grant_frames first. */
core_initcall(xen_pvh_gnttab_setup);
#endif
Commit	Line	Data
8d3d2106 IY	1	/******************************************************************************
	2	* grant_table.c
	3	* x86 specific part
	4	*
	5	* Granting foreign access to our memory reservation.
	6	*
	7	* Copyright (c) 2005-2006, Christopher Clark
	8	* Copyright (c) 2004-2005, K A Fraser
	9	* Copyright (c) 2008 Isaku Yamahata <yamahata at valinux co jp>
	10	* VA Linux Systems Japan. Split out x86 specific part.
	11	*
	12	* This program is free software; you can redistribute it and/or
	13	* modify it under the terms of the GNU General Public License version 2
	14	* as published by the Free Software Foundation; or, when distributed
	15	* separately from the Linux kernel or incorporated into other
	16	* software packages, subject to the following license:
	17	*
	18	* Permission is hereby granted, free of charge, to any person obtaining a copy
	19	* of this source file (the "Software"), to deal in the Software without
	20	* restriction, including without limitation the rights to use, copy, modify,
	21	* merge, publish, distribute, sublicense, and/or sell copies of the Software,
	22	* and to permit persons to whom the Software is furnished to do so, subject to
	23	* the following conditions:
	24	*
	25	* The above copyright notice and this permission notice shall be included in
	26	* all copies or substantial portions of the Software.
	27	*
	28	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	29	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	30	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	31	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	32	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	33	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
	34	* IN THE SOFTWARE.
	35	*/
	36
	37	#include <linux/sched.h>
	38	#include <linux/mm.h>
	39	#include <linux/vmalloc.h>
	40
	41	#include <xen/interface/xen.h>
	42	#include <xen/page.h>
	43	#include <xen/grant_table.h>
	44
	45	#include <asm/pgtable.h>
	46
	47	static int map_pte_fn(pte_t pte, struct page pmd_page,
	48	unsigned long addr, void *data)
	49	{
	50	unsigned long frames = (unsigned long )data;
	51
	52	set_pte_at(&init_mm, addr, pte, mfn_pte((*frames)[0], PAGE_KERNEL));
	53	(*frames)++;
	54	return 0;
	55	}
	56
85ff6acb AL	57	/*
	58	* This function is used to map shared frames to store grant status. It is
	59	* different from map_pte_fn above, the frames type here is uint64_t.
	60	*/
	61	static int map_pte_fn_status(pte_t pte, struct page pmd_page,
	62	unsigned long addr, void *data)
	63	{
	64	uint64_t frames = (uint64_t )data;
	65
	66	set_pte_at(&init_mm, addr, pte, mfn_pte((*frames)[0], PAGE_KERNEL));
	67	(*frames)++;
	68	return 0;
	69	}
	70
8d3d2106 IY	71	static int unmap_pte_fn(pte_t pte, struct page pmd_page,
	72	unsigned long addr, void *data)
	73	{
	74
	75	set_pte_at(&init_mm, addr, pte, __pte(0));
	76	return 0;
	77	}
	78
	79	int arch_gnttab_map_shared(unsigned long *frames, unsigned long nr_gframes,
	80	unsigned long max_nr_gframes,
0f9f5a95	81	void **__shared)
8d3d2106 IY	82	{
8d3d2106 IY	83	int rc;
0f9f5a95	84	void shared = __shared;
8d3d2106 IY	85
	86	if (shared == NULL) {
	87	struct vm_struct *area =
cd12909c	88	alloc_vm_area(PAGE_SIZE * max_nr_gframes, NULL);
8d3d2106 IY	89	BUG_ON(area == NULL);
	90	shared = area->addr;
	91	*__shared = shared;
	92	}
	93
	94	rc = apply_to_page_range(&init_mm, (unsigned long)shared,
	95	PAGE_SIZE * nr_gframes,
	96	map_pte_fn, &frames);
	97	return rc;
	98	}
	99
85ff6acb AL	100	int arch_gnttab_map_status(uint64_t *frames, unsigned long nr_gframes,
	101	unsigned long max_nr_gframes,
	102	grant_status_t **__shared)
	103	{
	104	int rc;
	105	grant_status_t shared = __shared;
	106
	107	if (shared == NULL) {
	108	/* No need to pass in PTE as we are going to do it
	109	* in apply_to_page_range anyhow. */
	110	struct vm_struct *area =
	111	alloc_vm_area(PAGE_SIZE * max_nr_gframes, NULL);
	112	BUG_ON(area == NULL);
	113	shared = area->addr;
	114	*__shared = shared;
	115	}
	116
	117	rc = apply_to_page_range(&init_mm, (unsigned long)shared,
	118	PAGE_SIZE * nr_gframes,
	119	map_pte_fn_status, &frames);
	120	return rc;
	121	}
	122
	123	void arch_gnttab_unmap(void *shared, unsigned long nr_gframes)
8d3d2106 IY	124	{
	125	apply_to_page_range(&init_mm, (unsigned long)shared,
	126	PAGE_SIZE * nr_gframes, unmap_pte_fn, NULL);
	127	}
6926f6d6 KRW	128	#ifdef CONFIG_XEN_PVH
	129	#include <xen/balloon.h>
	130	#include <xen/events.h>
0869a642	131	#include <xen/xen.h>
6926f6d6 KRW	132	#include <linux/slab.h>
	133	static int __init xlated_setup_gnttab_pages(void)
	134	{
	135	struct page **pages;
	136	xen_pfn_t *pfns;
	137	int rc;
	138	unsigned int i;
	139	unsigned long nr_grant_frames = gnttab_max_grant_frames();
	140
	141	BUG_ON(nr_grant_frames == 0);
	142	pages = kcalloc(nr_grant_frames, sizeof(pages[0]), GFP_KERNEL);
	143	if (!pages)
	144	return -ENOMEM;
	145
	146	pfns = kcalloc(nr_grant_frames, sizeof(pfns[0]), GFP_KERNEL);
	147	if (!pfns) {
	148	kfree(pages);
	149	return -ENOMEM;
	150	}
	151	rc = alloc_xenballooned_pages(nr_grant_frames, pages, 0 /* lowmem */);
	152	if (rc) {
	153	pr_warn("%s Couldn't balloon alloc %ld pfns rc:%d\n", __func__,
	154	nr_grant_frames, rc);
	155	kfree(pages);
	156	kfree(pfns);
	157	return rc;
	158	}
	159	for (i = 0; i < nr_grant_frames; i++)
	160	pfns[i] = page_to_pfn(pages[i]);
	161
	162	rc = arch_gnttab_map_shared(pfns, nr_grant_frames, nr_grant_frames,
	163	&xen_auto_xlat_grant_frames.vaddr);
	164
6926f6d6 KRW	165	if (rc) {
	166	pr_warn("%s Couldn't map %ld pfns rc:%d\n", __func__,
	167	nr_grant_frames, rc);
	168	free_xenballooned_pages(nr_grant_frames, pages);
f93576e1	169	kfree(pages);
6926f6d6 KRW	170	kfree(pfns);
	171	return rc;
	172	}
f93576e1	173	kfree(pages);
6926f6d6 KRW	174
	175	xen_auto_xlat_grant_frames.pfn = pfns;
	176	xen_auto_xlat_grant_frames.count = nr_grant_frames;
	177
	178	return 0;
	179	}
	180
	181	static int __init xen_pvh_gnttab_setup(void)
	182	{
	183	if (!xen_pvh_domain())
	184	return -ENODEV;
	185
	186	return xlated_setup_gnttab_pages();
	187	}
	188	/* Call it _before_ __gnttab_init as we need to initialize the
	189	* xen_auto_xlat_grant_frames first. */
	190	core_initcall(xen_pvh_gnttab_setup);
	191	#endif