[deliverable/linux.git] / drivers / xen / xenfs / privcmd.c

/******************************************************************************
 * privcmd.c
 *
 * Interface to privileged domain-0 commands.
 *
 * Copyright (c) 2002-2004, K A Fraser, B Dragovic
 */

#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/mman.h>
#include <linux/uaccess.h>
#include <linux/swap.h>
#include <linux/highmem.h>
#include <linux/pagemap.h>
#include <linux/seq_file.h>

#include <asm/pgalloc.h>
#include <asm/pgtable.h>
#include <asm/tlb.h>
#include <asm/xen/hypervisor.h>
#include <asm/xen/hypercall.h>

#include <xen/xen.h>
#include <xen/privcmd.h>
#include <xen/interface/xen.h>
#include <xen/features.h>
#include <xen/page.h>
#include <xen/xen-ops.h>

#ifndef HAVE_ARCH_PRIVCMD_MMAP
static int privcmd_enforce_singleshot_mapping(struct vm_area_struct *vma);
#endif

static long privcmd_ioctl_hypercall(void __user *udata)
{
	struct privcmd_hypercall hypercall;
	long ret;

	if (copy_from_user(&hypercall, udata, sizeof(hypercall)))
		return -EFAULT;

	ret = privcmd_call(hypercall.op,
			   hypercall.arg[0], hypercall.arg[1],
			   hypercall.arg[2], hypercall.arg[3],
			   hypercall.arg[4]);

	return ret;
}

static void free_page_list(struct list_head *pages)
{
	struct page *p, *n;

	list_for_each_entry_safe(p, n, pages, lru)
		__free_page(p);

	INIT_LIST_HEAD(pages);
}

/*
 * Given an array of items in userspace, return a list of pages
 * containing the data.  If copying fails, either because of memory
 * allocation failure or a problem reading user memory, return an
 * error code; its up to the caller to dispose of any partial list.
 */
static int gather_array(struct list_head *pagelist,
			unsigned nelem, size_t size,
			void __user *data)
{
	unsigned pageidx;
	void *pagedata;
	int ret;

	if (size > PAGE_SIZE)
		return 0;

	pageidx = PAGE_SIZE;
	pagedata = NULL;	/* quiet, gcc */
	while (nelem--) {
		if (pageidx > PAGE_SIZE-size) {
			struct page *page = alloc_page(GFP_KERNEL);

			ret = -ENOMEM;
			if (page == NULL)
				goto fail;

			pagedata = page_address(page);

			list_add_tail(&page->lru, pagelist);
			pageidx = 0;
		}

		ret = -EFAULT;
		if (copy_from_user(pagedata + pageidx, data, size))
			goto fail;

		data += size;
		pageidx += size;
	}

	ret = 0;

fail:
	return ret;
}

/*
 * Call function "fn" on each element of the array fragmented
 * over a list of pages.
 */
static int traverse_pages(unsigned nelem, size_t size,
			  struct list_head *pos,
			  int (*fn)(void *data, void *state),
			  void *state)
{
	void *pagedata;
	unsigned pageidx;
	int ret = 0;

	BUG_ON(size > PAGE_SIZE);

	pageidx = PAGE_SIZE;
	pagedata = NULL;	/* hush, gcc */

	while (nelem--) {
		if (pageidx > PAGE_SIZE-size) {
			struct page *page;
			pos = pos->next;
			page = list_entry(pos, struct page, lru);
			pagedata = page_address(page);
			pageidx = 0;
		}

		ret = (*fn)(pagedata + pageidx, state);
		if (ret)
			break;
		pageidx += size;
	}

	return ret;
}

struct mmap_mfn_state {
	unsigned long va;
	struct vm_area_struct *vma;
	domid_t domain;
};

static int mmap_mfn_range(void *data, void *state)
{
	struct privcmd_mmap_entry *msg = data;
	struct mmap_mfn_state *st = state;
	struct vm_area_struct *vma = st->vma;
	int rc;

	/* Do not allow range to wrap the address space. */
	if ((msg->npages > (LONG_MAX >> PAGE_SHIFT)) ||
	    ((unsigned long)(msg->npages << PAGE_SHIFT) >= -st->va))
		return -EINVAL;

	/* Range chunks must be contiguous in va space. */
	if ((msg->va != st->va) ||
	    ((msg->va+(msg->npages<<PAGE_SHIFT)) > vma->vm_end))
		return -EINVAL;

	rc = xen_remap_domain_mfn_range(vma,
					msg->va & PAGE_MASK,
					msg->mfn, msg->npages,
					vma->vm_page_prot,
					st->domain);
	if (rc < 0)
		return rc;

	st->va += msg->npages << PAGE_SHIFT;

	return 0;
}

static long privcmd_ioctl_mmap(void __user *udata)
{
	struct privcmd_mmap mmapcmd;
	struct mm_struct *mm = current->mm;
	struct vm_area_struct *vma;
	int rc;
	LIST_HEAD(pagelist);
	struct mmap_mfn_state state;

	if (!xen_initial_domain())
		return -EPERM;

	if (copy_from_user(&mmapcmd, udata, sizeof(mmapcmd)))
		return -EFAULT;

	rc = gather_array(&pagelist,
			  mmapcmd.num, sizeof(struct privcmd_mmap_entry),
			  mmapcmd.entry);

	if (rc || list_empty(&pagelist))
		goto out;

	down_write(&mm->mmap_sem);

	{
		struct page *page = list_first_entry(&pagelist,
						     struct page, lru);
		struct privcmd_mmap_entry *msg = page_address(page);

		vma = find_vma(mm, msg->va);
		rc = -EINVAL;

		if (!vma || (msg->va != vma->vm_start) ||
		    !privcmd_enforce_singleshot_mapping(vma))
			goto out_up;
	}

	state.va = vma->vm_start;
	state.vma = vma;
	state.domain = mmapcmd.dom;

	rc = traverse_pages(mmapcmd.num, sizeof(struct privcmd_mmap_entry),
			    &pagelist,
			    mmap_mfn_range, &state);


out_up:
	up_write(&mm->mmap_sem);

out:
	free_page_list(&pagelist);

	return rc;
}

struct mmap_batch_state {
	domid_t domain;
	unsigned long va;
	struct vm_area_struct *vma;
	int err;

	xen_pfn_t __user *user;
};

static int mmap_batch_fn(void *data, void *state)
{
	xen_pfn_t *mfnp = data;
	struct mmap_batch_state *st = state;

	if (xen_remap_domain_mfn_range(st->vma, st->va & PAGE_MASK, *mfnp, 1,
				       st->vma->vm_page_prot, st->domain) < 0) {
		*mfnp |= 0xf0000000U;
		st->err++;
	}
	st->va += PAGE_SIZE;

	return 0;
}

static int mmap_return_errors(void *data, void *state)
{
	xen_pfn_t *mfnp = data;
	struct mmap_batch_state *st = state;

	return put_user(*mfnp, st->user++);
}

static struct vm_operations_struct privcmd_vm_ops;

static long privcmd_ioctl_mmap_batch(void __user *udata)
{
	int ret;
	struct privcmd_mmapbatch m;
	struct mm_struct *mm = current->mm;
	struct vm_area_struct *vma;
	unsigned long nr_pages;
	LIST_HEAD(pagelist);
	struct mmap_batch_state state;

	if (!xen_initial_domain())
		return -EPERM;

	if (copy_from_user(&m, udata, sizeof(m)))
		return -EFAULT;

	nr_pages = m.num;
	if ((m.num <= 0) || (nr_pages > (LONG_MAX >> PAGE_SHIFT)))
		return -EINVAL;

	ret = gather_array(&pagelist, m.num, sizeof(xen_pfn_t),
			   m.arr);

	if (ret || list_empty(&pagelist))
		goto out;

	down_write(&mm->mmap_sem);

	vma = find_vma(mm, m.addr);
	ret = -EINVAL;
	if (!vma ||
	    vma->vm_ops != &privcmd_vm_ops ||
	    (m.addr != vma->vm_start) ||
	    ((m.addr + (nr_pages << PAGE_SHIFT)) != vma->vm_end) ||
	    !privcmd_enforce_singleshot_mapping(vma)) {
		up_write(&mm->mmap_sem);
		goto out;
	}

	state.domain = m.dom;
	state.vma = vma;
	state.va = m.addr;
	state.err = 0;

	ret = traverse_pages(m.num, sizeof(xen_pfn_t),
			     &pagelist, mmap_batch_fn, &state);

	up_write(&mm->mmap_sem);

	if (state.err > 0) {
		state.user = m.arr;
		ret = traverse_pages(m.num, sizeof(xen_pfn_t),
			       &pagelist,
			       mmap_return_errors, &state);
	}

out:
	free_page_list(&pagelist);

	return ret;
}

static long privcmd_ioctl(struct file *file,
			  unsigned int cmd, unsigned long data)
{
	int ret = -ENOSYS;
	void __user *udata = (void __user *) data;

	switch (cmd) {
	case IOCTL_PRIVCMD_HYPERCALL:
		ret = privcmd_ioctl_hypercall(udata);
		break;

	case IOCTL_PRIVCMD_MMAP:
		ret = privcmd_ioctl_mmap(udata);
		break;

	case IOCTL_PRIVCMD_MMAPBATCH:
		ret = privcmd_ioctl_mmap_batch(udata);
		break;

	default:
		ret = -EINVAL;
		break;
	}

	return ret;
}

#ifndef HAVE_ARCH_PRIVCMD_MMAP
static int privcmd_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
{
	printk(KERN_DEBUG "privcmd_fault: vma=%p %lx-%lx, pgoff=%lx, uv=%p\n",
	       vma, vma->vm_start, vma->vm_end,
	       vmf->pgoff, vmf->virtual_address);

	return VM_FAULT_SIGBUS;
}

static struct vm_operations_struct privcmd_vm_ops = {
	.fault = privcmd_fault
};

static int privcmd_mmap(struct file *file, struct vm_area_struct *vma)
{
	/* Unsupported for auto-translate guests. */
	if (xen_feature(XENFEAT_auto_translated_physmap))
		return -ENOSYS;

	/* DONTCOPY is essential for Xen because copy_page_range doesn't know
	 * how to recreate these mappings */
	vma->vm_flags |= VM_RESERVED | VM_IO | VM_DONTCOPY | VM_PFNMAP;
	vma->vm_ops = &privcmd_vm_ops;
	vma->vm_private_data = NULL;

	return 0;
}

static int privcmd_enforce_singleshot_mapping(struct vm_area_struct *vma)
{
	return (xchg(&vma->vm_private_data, (void *)1) == NULL);
}
#endif

const struct file_operations privcmd_file_ops = {
	.unlocked_ioctl = privcmd_ioctl,
	.mmap = privcmd_mmap,
};
Commit	Line	Data
1c5de193 JF	1	/******************************************************************************
	2	* privcmd.c
	3	*
	4	* Interface to privileged domain-0 commands.
	5	*
	6	* Copyright (c) 2002-2004, K A Fraser, B Dragovic
	7	*/
	8
	9	#include <linux/kernel.h>
	10	#include <linux/sched.h>
	11	#include <linux/slab.h>
	12	#include <linux/string.h>
	13	#include <linux/errno.h>
	14	#include <linux/mm.h>
	15	#include <linux/mman.h>
	16	#include <linux/uaccess.h>
	17	#include <linux/swap.h>
1c5de193 JF	18	#include <linux/highmem.h>
	19	#include <linux/pagemap.h>
	20	#include <linux/seq_file.h>
	21
	22	#include <asm/pgalloc.h>
	23	#include <asm/pgtable.h>
	24	#include <asm/tlb.h>
	25	#include <asm/xen/hypervisor.h>
	26	#include <asm/xen/hypercall.h>
	27
	28	#include <xen/xen.h>
	29	#include <xen/privcmd.h>
	30	#include <xen/interface/xen.h>
	31	#include <xen/features.h>
	32	#include <xen/page.h>
de1ef206	33	#include <xen/xen-ops.h>
f020e290	34
1c5de193 JF	35	#ifndef HAVE_ARCH_PRIVCMD_MMAP
	36	static int privcmd_enforce_singleshot_mapping(struct vm_area_struct *vma);
	37	#endif
	38
1c5de193 JF	39	static long privcmd_ioctl_hypercall(void __user *udata)
	40	{
	41	struct privcmd_hypercall hypercall;
	42	long ret;
	43
	44	if (copy_from_user(&hypercall, udata, sizeof(hypercall)))
	45	return -EFAULT;
	46
	47	ret = privcmd_call(hypercall.op,
	48	hypercall.arg[0], hypercall.arg[1],
	49	hypercall.arg[2], hypercall.arg[3],
	50	hypercall.arg[4]);
	51
	52	return ret;
	53	}
	54
	55	static void free_page_list(struct list_head *pages)
	56	{
	57	struct page p, n;
	58
	59	list_for_each_entry_safe(p, n, pages, lru)
	60	__free_page(p);
	61
	62	INIT_LIST_HEAD(pages);
	63	}
	64
	65	/*
	66	* Given an array of items in userspace, return a list of pages
	67	* containing the data. If copying fails, either because of memory
	68	* allocation failure or a problem reading user memory, return an
	69	* error code; its up to the caller to dispose of any partial list.
	70	*/
	71	static int gather_array(struct list_head *pagelist,
	72	unsigned nelem, size_t size,
	73	void __user *data)
	74	{
	75	unsigned pageidx;
	76	void *pagedata;
	77	int ret;
	78
	79	if (size > PAGE_SIZE)
	80	return 0;
	81
	82	pageidx = PAGE_SIZE;
	83	pagedata = NULL; /* quiet, gcc */
	84	while (nelem--) {
	85	if (pageidx > PAGE_SIZE-size) {
	86	struct page *page = alloc_page(GFP_KERNEL);
	87
	88	ret = -ENOMEM;
	89	if (page == NULL)
	90	goto fail;
	91
	92	pagedata = page_address(page);
	93
	94	list_add_tail(&page->lru, pagelist);
	95	pageidx = 0;
	96	}
	97
	98	ret = -EFAULT;
	99	if (copy_from_user(pagedata + pageidx, data, size))
	100	goto fail;
	101
	102	data += size;
103	pageidx += size;
104	}
105
106	ret = 0;
107
108	fail:
109	return ret;
110	}
111
112	/*
113	* Call function "fn" on each element of the array fragmented
114	* over a list of pages.
115	*/
116	static int traverse_pages(unsigned nelem, size_t size,
117	struct list_head *pos,
118	int (fn)(void data, void *state),
119	void *state)
120	{
121	void *pagedata;
122	unsigned pageidx;
f020e290	123	int ret = 0;
1c5de193 JF	124
	125	BUG_ON(size > PAGE_SIZE);
	126
	127	pageidx = PAGE_SIZE;
	128	pagedata = NULL; /* hush, gcc */
	129
	130	while (nelem--) {
	131	if (pageidx > PAGE_SIZE-size) {
	132	struct page *page;
	133	pos = pos->next;
	134	page = list_entry(pos, struct page, lru);
	135	pagedata = page_address(page);
	136	pageidx = 0;
	137	}
	138
	139	ret = (*fn)(pagedata + pageidx, state);
	140	if (ret)
	141	break;
	142	pageidx += size;
	143	}
	144
	145	return ret;
	146	}
	147
	148	struct mmap_mfn_state {
	149	unsigned long va;
	150	struct vm_area_struct *vma;
	151	domid_t domain;
	152	};
	153
	154	static int mmap_mfn_range(void data, void state)
	155	{
	156	struct privcmd_mmap_entry *msg = data;
	157	struct mmap_mfn_state *st = state;
	158	struct vm_area_struct *vma = st->vma;
	159	int rc;
	160
	161	/* Do not allow range to wrap the address space. */
	162	if ((msg->npages > (LONG_MAX >> PAGE_SHIFT)) \|\|
	163	((unsigned long)(msg->npages << PAGE_SHIFT) >= -st->va))
	164	return -EINVAL;
	165
	166	/* Range chunks must be contiguous in va space. */
	167	if ((msg->va != st->va) \|\|
	168	((msg->va+(msg->npages<<PAGE_SHIFT)) > vma->vm_end))
	169	return -EINVAL;
	170
de1ef206 IC	171	rc = xen_remap_domain_mfn_range(vma,
	172	msg->va & PAGE_MASK,
	173	msg->mfn, msg->npages,
	174	vma->vm_page_prot,
	175	st->domain);
1c5de193 JF	176	if (rc < 0)
	177	return rc;
	178
	179	st->va += msg->npages << PAGE_SHIFT;
	180
	181	return 0;
	182	}
	183
	184	static long privcmd_ioctl_mmap(void __user *udata)
	185	{
	186	struct privcmd_mmap mmapcmd;
	187	struct mm_struct *mm = current->mm;
	188	struct vm_area_struct *vma;
	189	int rc;
	190	LIST_HEAD(pagelist);
	191	struct mmap_mfn_state state;
	192
	193	if (!xen_initial_domain())
	194	return -EPERM;
	195
	196	if (copy_from_user(&mmapcmd, udata, sizeof(mmapcmd)))
	197	return -EFAULT;
	198
	199	rc = gather_array(&pagelist,
	200	mmapcmd.num, sizeof(struct privcmd_mmap_entry),
	201	mmapcmd.entry);
	202
	203	if (rc \|\| list_empty(&pagelist))
	204	goto out;
	205
	206	down_write(&mm->mmap_sem);
	207
	208	{
	209	struct page *page = list_first_entry(&pagelist,
	210	struct page, lru);
	211	struct privcmd_mmap_entry *msg = page_address(page);
	212
	213	vma = find_vma(mm, msg->va);
	214	rc = -EINVAL;
	215
	216	if (!vma \|\| (msg->va != vma->vm_start) \|\|
	217	!privcmd_enforce_singleshot_mapping(vma))
	218	goto out_up;
	219	}
	220
	221	state.va = vma->vm_start;
	222	state.vma = vma;
	223	state.domain = mmapcmd.dom;
	224
	225	rc = traverse_pages(mmapcmd.num, sizeof(struct privcmd_mmap_entry),
	226	&pagelist,
	227	mmap_mfn_range, &state);
	228
	229
	230	out_up:
	231	up_write(&mm->mmap_sem);
	232
	233	out:
	234	free_page_list(&pagelist);
	235
	236	return rc;
	237	}
	238
	239	struct mmap_batch_state {
240	domid_t domain;
241	unsigned long va;
242	struct vm_area_struct *vma;
243	int err;
244
245	xen_pfn_t __user *user;
246	};
247
248	static int mmap_batch_fn(void data, void state)
249	{
250	xen_pfn_t *mfnp = data;
251	struct mmap_batch_state *st = state;
252
de1ef206 IC	253	if (xen_remap_domain_mfn_range(st->vma, st->va & PAGE_MASK, *mfnp, 1,
de1ef206 IC	254	st->vma->vm_page_prot, st->domain) < 0) {
1c5de193 JF	255	*mfnp \|= 0xf0000000U;
	256	st->err++;
	257	}
	258	st->va += PAGE_SIZE;
	259
	260	return 0;
	261	}
	262
	263	static int mmap_return_errors(void data, void state)
	264	{
	265	xen_pfn_t *mfnp = data;
	266	struct mmap_batch_state *st = state;
	267
313e7441	268	return put_user(*mfnp, st->user++);
1c5de193 JF	269	}
1c5de193 JF	270
f31fdf51 JF	271	static struct vm_operations_struct privcmd_vm_ops;
f31fdf51 JF	272
1c5de193 JF	273	static long privcmd_ioctl_mmap_batch(void __user *udata)
	274	{
	275	int ret;
	276	struct privcmd_mmapbatch m;
	277	struct mm_struct *mm = current->mm;
	278	struct vm_area_struct *vma;
	279	unsigned long nr_pages;
	280	LIST_HEAD(pagelist);
	281	struct mmap_batch_state state;
	282
	283	if (!xen_initial_domain())
	284	return -EPERM;
	285
	286	if (copy_from_user(&m, udata, sizeof(m)))
	287	return -EFAULT;
	288
	289	nr_pages = m.num;
	290	if ((m.num <= 0) \|\| (nr_pages > (LONG_MAX >> PAGE_SHIFT)))
	291	return -EINVAL;
	292
	293	ret = gather_array(&pagelist, m.num, sizeof(xen_pfn_t),
	294	m.arr);
	295
	296	if (ret \|\| list_empty(&pagelist))
	297	goto out;
	298
	299	down_write(&mm->mmap_sem);
	300
	301	vma = find_vma(mm, m.addr);
	302	ret = -EINVAL;
	303	if (!vma \|\|
f31fdf51	304	vma->vm_ops != &privcmd_vm_ops \|\|
1c5de193 JF	305	(m.addr != vma->vm_start) \|\|
	306	((m.addr + (nr_pages << PAGE_SHIFT)) != vma->vm_end) \|\|
	307	!privcmd_enforce_singleshot_mapping(vma)) {
	308	up_write(&mm->mmap_sem);
	309	goto out;
	310	}
	311
	312	state.domain = m.dom;
	313	state.vma = vma;
	314	state.va = m.addr;
	315	state.err = 0;
	316
	317	ret = traverse_pages(m.num, sizeof(xen_pfn_t),
	318	&pagelist, mmap_batch_fn, &state);
	319
	320	up_write(&mm->mmap_sem);
	321
	322	if (state.err > 0) {
f020e290	323	state.user = m.arr;
313e7441	324	ret = traverse_pages(m.num, sizeof(xen_pfn_t),
1c5de193 JF	325	&pagelist,
	326	mmap_return_errors, &state);
	327	}
	328
	329	out:
	330	free_page_list(&pagelist);
	331
	332	return ret;
	333	}
	334
	335	static long privcmd_ioctl(struct file *file,
	336	unsigned int cmd, unsigned long data)
	337	{
	338	int ret = -ENOSYS;
	339	void __user udata = (void __user ) data;
	340
	341	switch (cmd) {
	342	case IOCTL_PRIVCMD_HYPERCALL:
	343	ret = privcmd_ioctl_hypercall(udata);
	344	break;
	345
	346	case IOCTL_PRIVCMD_MMAP:
	347	ret = privcmd_ioctl_mmap(udata);
	348	break;
	349
	350	case IOCTL_PRIVCMD_MMAPBATCH:
	351	ret = privcmd_ioctl_mmap_batch(udata);
	352	break;
	353
	354	default:
	355	ret = -EINVAL;
	356	break;
	357	}
	358
	359	return ret;
	360	}
	361
	362	#ifndef HAVE_ARCH_PRIVCMD_MMAP
	363	static int privcmd_fault(struct vm_area_struct vma, struct vm_fault vmf)
	364	{
441c7416 JF	365	printk(KERN_DEBUG "privcmd_fault: vma=%p %lx-%lx, pgoff=%lx, uv=%p\n",
	366	vma, vma->vm_start, vma->vm_end,
	367	vmf->pgoff, vmf->virtual_address);
	368
1c5de193 JF	369	return VM_FAULT_SIGBUS;
	370	}
	371
	372	static struct vm_operations_struct privcmd_vm_ops = {
	373	.fault = privcmd_fault
	374	};
	375
	376	static int privcmd_mmap(struct file file, struct vm_area_struct vma)
	377	{
	378	/* Unsupported for auto-translate guests. */
	379	if (xen_feature(XENFEAT_auto_translated_physmap))
	380	return -ENOSYS;
	381
e060e7af SS	382	/* DONTCOPY is essential for Xen because copy_page_range doesn't know
	383	* how to recreate these mappings */
	384	vma->vm_flags \|= VM_RESERVED \| VM_IO \| VM_DONTCOPY \| VM_PFNMAP;
1c5de193 JF	385	vma->vm_ops = &privcmd_vm_ops;
	386	vma->vm_private_data = NULL;
	387
	388	return 0;
	389	}
	390
	391	static int privcmd_enforce_singleshot_mapping(struct vm_area_struct *vma)
	392	{
	393	return (xchg(&vma->vm_private_data, (void *)1) == NULL);
	394	}
	395	#endif
	396
	397	const struct file_operations privcmd_file_ops = {
	398	.unlocked_ioctl = privcmd_ioctl,
	399	.mmap = privcmd_mmap,
	400	};