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