[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / xen / 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/module.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 <linux/miscdevice.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>

#include "privcmd.h"

MODULE_LICENSE("GPL");

#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 xen_privcmd_fops = {
	.owner = THIS_MODULE,
	.unlocked_ioctl = privcmd_ioctl,
	.mmap = privcmd_mmap,
};
EXPORT_SYMBOL_GPL(xen_privcmd_fops);

static struct miscdevice privcmd_dev = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = "xen/privcmd",
	.fops = &xen_privcmd_fops,
};

static int __init privcmd_init(void)
{
	int err;

	if (!xen_domain())
		return -ENODEV;

	err = misc_register(&privcmd_dev);
	if (err != 0) {
		printk(KERN_ERR "Could not register Xen privcmd device\n");
		return err;
	}
	return 0;
}

static void __exit privcmd_exit(void)
{
	misc_deregister(&privcmd_dev);
}

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