[linux-2.6-block.git] / arch / x86 / vdso / vma.c

/*
 * Set up the VMAs to tell the VM about the vDSO.
 * Copyright 2007 Andi Kleen, SUSE Labs.
 * Subject to the GPL, v.2
 */
#include <linux/mm.h>
#include <linux/err.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/random.h>
#include <asm/vsyscall.h>
#include <asm/vgtod.h>
#include <asm/proto.h>
#include <asm/vdso.h>

#include "vextern.h"		/* Just for VMAGIC.  */
#undef VEXTERN

unsigned int __read_mostly vdso_enabled = 1;

extern char vdso_start[], vdso_end[];
extern unsigned short vdso_sync_cpuid;

static struct page **vdso_pages;
static unsigned vdso_size;

static inline void *var_ref(void *p, char *name)
{
	if (*(void **)p != (void *)VMAGIC) {
		printk("VDSO: variable %s broken\n", name);
		vdso_enabled = 0;
	}
	return p;
}

static int __init init_vdso_vars(void)
{
	int npages = (vdso_end - vdso_start + PAGE_SIZE - 1) / PAGE_SIZE;
	int i;
	char *vbase;

	vdso_size = npages << PAGE_SHIFT;
	vdso_pages = kmalloc(sizeof(struct page *) * npages, GFP_KERNEL);
	if (!vdso_pages)
		goto oom;
	for (i = 0; i < npages; i++) {
		struct page *p;
		p = alloc_page(GFP_KERNEL);
		if (!p)
			goto oom;
		vdso_pages[i] = p;
		copy_page(page_address(p), vdso_start + i*PAGE_SIZE);
	}

	vbase = vmap(vdso_pages, npages, 0, PAGE_KERNEL);
	if (!vbase)
		goto oom;

	if (memcmp(vbase, "\177ELF", 4)) {
		printk("VDSO: I'm broken; not ELF\n");
		vdso_enabled = 0;
	}

#define VEXTERN(x) \
	*(typeof(__ ## x) **) var_ref(VDSO64_SYMBOL(vbase, x), #x) = &__ ## x;
#include "vextern.h"
#undef VEXTERN
	return 0;

 oom:
	printk("Cannot allocate vdso\n");
	vdso_enabled = 0;
	return -ENOMEM;
}
__initcall(init_vdso_vars);

struct linux_binprm;

/* Put the vdso above the (randomized) stack with another randomized offset.
   This way there is no hole in the middle of address space.
   To save memory make sure it is still in the same PTE as the stack top.
   This doesn't give that many random bits */
static unsigned long vdso_addr(unsigned long start, unsigned len)
{
	unsigned long addr, end;
	unsigned offset;
	end = (start + PMD_SIZE - 1) & PMD_MASK;
	if (end >= TASK_SIZE_MAX)
		end = TASK_SIZE_MAX;
	end -= len;
	/* This loses some more bits than a modulo, but is cheaper */
	offset = get_random_int() & (PTRS_PER_PTE - 1);
	addr = start + (offset << PAGE_SHIFT);
	if (addr >= end)
		addr = end;
	return addr;
}

/* Setup a VMA at program startup for the vsyscall page.
   Not called for compat tasks */
int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
{
	struct mm_struct *mm = current->mm;
	unsigned long addr;
	int ret;

	if (!vdso_enabled)
		return 0;

	down_write(&mm->mmap_sem);
	addr = vdso_addr(mm->start_stack, vdso_size);
	addr = get_unmapped_area(NULL, addr, vdso_size, 0, 0);
	if (IS_ERR_VALUE(addr)) {
		ret = addr;
		goto up_fail;
	}

	ret = install_special_mapping(mm, addr, vdso_size,
				      VM_READ|VM_EXEC|
				      VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC|
				      VM_ALWAYSDUMP,
				      vdso_pages);
	if (ret)
		goto up_fail;

	current->mm->context.vdso = (void *)addr;
up_fail:
	up_write(&mm->mmap_sem);
	return ret;
}

static __init int vdso_setup(char *s)
{
	vdso_enabled = simple_strtoul(s, NULL, 0);
	return 0;
}
__setup("vdso=", vdso_setup);
Commit	Line	Data
2aae950b AK	1	/*
	2	* Set up the VMAs to tell the VM about the vDSO.
	3	* Copyright 2007 Andi Kleen, SUSE Labs.
	4	* Subject to the GPL, v.2
	5	*/
	6	#include <linux/mm.h>
4e950f6f	7	#include <linux/err.h>
2aae950b AK	8	#include <linux/sched.h>
	9	#include <linux/init.h>
	10	#include <linux/random.h>
	11	#include <asm/vsyscall.h>
	12	#include <asm/vgtod.h>
	13	#include <asm/proto.h>
7f3646aa	14	#include <asm/vdso.h>
2aae950b	15
7f3646aa	16	#include "vextern.h" /* Just for VMAGIC. */
2aae950b AK	17	#undef VEXTERN
2aae950b AK	18
e6b0edef	19	unsigned int __read_mostly vdso_enabled = 1;
7f3646aa RM	20
7f3646aa RM	21	extern char vdso_start[], vdso_end[];
2aae950b AK	22	extern unsigned short vdso_sync_cpuid;
2aae950b AK	23
369c9920 JB	24	static struct page **vdso_pages;
369c9920 JB	25	static unsigned vdso_size;
2aae950b	26
7f3646aa	27	static inline void var_ref(void p, char *name)
2aae950b	28	{
2aae950b AK	29	if ((void )p != (void )VMAGIC) {
	30	printk("VDSO: variable %s broken\n", name);
	31	vdso_enabled = 0;
	32	}
	33	return p;
	34	}
	35
	36	static int __init init_vdso_vars(void)
	37	{
	38	int npages = (vdso_end - vdso_start + PAGE_SIZE - 1) / PAGE_SIZE;
	39	int i;
	40	char *vbase;
	41
369c9920	42	vdso_size = npages << PAGE_SHIFT;
2aae950b AK	43	vdso_pages = kmalloc(sizeof(struct page ) npages, GFP_KERNEL);
	44	if (!vdso_pages)
	45	goto oom;
	46	for (i = 0; i < npages; i++) {
	47	struct page *p;
	48	p = alloc_page(GFP_KERNEL);
	49	if (!p)
	50	goto oom;
	51	vdso_pages[i] = p;
	52	copy_page(page_address(p), vdso_start + i*PAGE_SIZE);
	53	}
	54
	55	vbase = vmap(vdso_pages, npages, 0, PAGE_KERNEL);
	56	if (!vbase)
	57	goto oom;
	58
	59	if (memcmp(vbase, "\177ELF", 4)) {
	60	printk("VDSO: I'm broken; not ELF\n");
	61	vdso_enabled = 0;
	62	}
	63
2aae950b	64	#define VEXTERN(x) \
7f3646aa	65	(typeof(__ ## x) *) var_ref(VDSO64_SYMBOL(vbase, x), #x) = &__ ## x;
2aae950b AK	66	#include "vextern.h"
	67	#undef VEXTERN
	68	return 0;
	69
	70	oom:
	71	printk("Cannot allocate vdso\n");
	72	vdso_enabled = 0;
	73	return -ENOMEM;
	74	}
	75	__initcall(init_vdso_vars);
	76
	77	struct linux_binprm;
	78
	79	/* Put the vdso above the (randomized) stack with another randomized offset.
	80	This way there is no hole in the middle of address space.
	81	To save memory make sure it is still in the same PTE as the stack top.
	82	This doesn't give that many random bits */
	83	static unsigned long vdso_addr(unsigned long start, unsigned len)
	84	{
	85	unsigned long addr, end;
	86	unsigned offset;
	87	end = (start + PMD_SIZE - 1) & PMD_MASK;
d9517346 IM	88	if (end >= TASK_SIZE_MAX)
d9517346 IM	89	end = TASK_SIZE_MAX;
2aae950b AK	90	end -= len;
	91	/* This loses some more bits than a modulo, but is cheaper */
	92	offset = get_random_int() & (PTRS_PER_PTE - 1);
	93	addr = start + (offset << PAGE_SHIFT);
	94	if (addr >= end)
	95	addr = end;
	96	return addr;
	97	}
	98
	99	/* Setup a VMA at program startup for the vsyscall page.
	100	Not called for compat tasks */
fc5243d9	101	int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
2aae950b AK	102	{
	103	struct mm_struct *mm = current->mm;
	104	unsigned long addr;
	105	int ret;
2aae950b AK	106
	107	if (!vdso_enabled)
	108	return 0;
	109
	110	down_write(&mm->mmap_sem);
369c9920 JB	111	addr = vdso_addr(mm->start_stack, vdso_size);
369c9920 JB	112	addr = get_unmapped_area(NULL, addr, vdso_size, 0, 0);
2aae950b AK	113	if (IS_ERR_VALUE(addr)) {
	114	ret = addr;
	115	goto up_fail;
	116	}
	117
369c9920	118	ret = install_special_mapping(mm, addr, vdso_size,
2aae950b AK	119	VM_READ\|VM_EXEC\|
	120	VM_MAYREAD\|VM_MAYWRITE\|VM_MAYEXEC\|
	121	VM_ALWAYSDUMP,
	122	vdso_pages);
	123	if (ret)
	124	goto up_fail;
	125
	126	current->mm->context.vdso = (void *)addr;
	127	up_fail:
	128	up_write(&mm->mmap_sem);
	129	return ret;
	130	}
	131
	132	static __init int vdso_setup(char *s)
	133	{
	134	vdso_enabled = simple_strtoul(s, NULL, 0);
	135	return 0;
	136	}
	137	__setup("vdso=", vdso_setup);