[PATCH] i386 vDSO: use VM_ALWAYSDUMP
[sfrench/cifs-2.6.git] / arch / i386 / kernel / sysenter.c
1 /*
2  * linux/arch/i386/kernel/sysenter.c
3  *
4  * (C) Copyright 2002 Linus Torvalds
5  * Portions based on the vdso-randomization code from exec-shield:
6  * Copyright(C) 2005-2006, Red Hat, Inc., Ingo Molnar
7  *
8  * This file contains the needed initializations to support sysenter.
9  */
10
11 #include <linux/init.h>
12 #include <linux/smp.h>
13 #include <linux/thread_info.h>
14 #include <linux/sched.h>
15 #include <linux/gfp.h>
16 #include <linux/string.h>
17 #include <linux/elf.h>
18 #include <linux/mm.h>
19 #include <linux/module.h>
20
21 #include <asm/cpufeature.h>
22 #include <asm/msr.h>
23 #include <asm/pgtable.h>
24 #include <asm/unistd.h>
25
26 /*
27  * Should the kernel map a VDSO page into processes and pass its
28  * address down to glibc upon exec()?
29  */
30 #ifdef CONFIG_PARAVIRT
31 unsigned int __read_mostly vdso_enabled = 0;
32 #else
33 unsigned int __read_mostly vdso_enabled = 1;
34 #endif
35
36 EXPORT_SYMBOL_GPL(vdso_enabled);
37
38 static int __init vdso_setup(char *s)
39 {
40         vdso_enabled = simple_strtoul(s, NULL, 0);
41
42         return 1;
43 }
44
45 __setup("vdso=", vdso_setup);
46
47 extern asmlinkage void sysenter_entry(void);
48
49 void enable_sep_cpu(void)
50 {
51         int cpu = get_cpu();
52         struct tss_struct *tss = &per_cpu(init_tss, cpu);
53
54         if (!boot_cpu_has(X86_FEATURE_SEP)) {
55                 put_cpu();
56                 return;
57         }
58
59         tss->ss1 = __KERNEL_CS;
60         tss->esp1 = sizeof(struct tss_struct) + (unsigned long) tss;
61         wrmsr(MSR_IA32_SYSENTER_CS, __KERNEL_CS, 0);
62         wrmsr(MSR_IA32_SYSENTER_ESP, tss->esp1, 0);
63         wrmsr(MSR_IA32_SYSENTER_EIP, (unsigned long) sysenter_entry, 0);
64         put_cpu();      
65 }
66
67 /*
68  * These symbols are defined by vsyscall.o to mark the bounds
69  * of the ELF DSO images included therein.
70  */
71 extern const char vsyscall_int80_start, vsyscall_int80_end;
72 extern const char vsyscall_sysenter_start, vsyscall_sysenter_end;
73 static void *syscall_page;
74
75 int __init sysenter_setup(void)
76 {
77         syscall_page = (void *)get_zeroed_page(GFP_ATOMIC);
78
79 #ifdef CONFIG_COMPAT_VDSO
80         __set_fixmap(FIX_VDSO, __pa(syscall_page), PAGE_READONLY);
81         printk("Compat vDSO mapped to %08lx.\n", __fix_to_virt(FIX_VDSO));
82 #endif
83
84         if (!boot_cpu_has(X86_FEATURE_SEP)) {
85                 memcpy(syscall_page,
86                        &vsyscall_int80_start,
87                        &vsyscall_int80_end - &vsyscall_int80_start);
88                 return 0;
89         }
90
91         memcpy(syscall_page,
92                &vsyscall_sysenter_start,
93                &vsyscall_sysenter_end - &vsyscall_sysenter_start);
94
95         return 0;
96 }
97
98 #ifndef CONFIG_COMPAT_VDSO
99 static struct page *syscall_nopage(struct vm_area_struct *vma,
100                                 unsigned long adr, int *type)
101 {
102         struct page *p = virt_to_page(adr - vma->vm_start + syscall_page);
103         get_page(p);
104         return p;
105 }
106
107 /* Prevent VMA merging */
108 static void syscall_vma_close(struct vm_area_struct *vma)
109 {
110 }
111
112 static struct vm_operations_struct syscall_vm_ops = {
113         .close = syscall_vma_close,
114         .nopage = syscall_nopage,
115 };
116
117 /* Defined in vsyscall-sysenter.S */
118 extern void SYSENTER_RETURN;
119
120 /* Setup a VMA at program startup for the vsyscall page */
121 int arch_setup_additional_pages(struct linux_binprm *bprm, int exstack)
122 {
123         struct vm_area_struct *vma;
124         struct mm_struct *mm = current->mm;
125         unsigned long addr;
126         int ret;
127
128         down_write(&mm->mmap_sem);
129         addr = get_unmapped_area(NULL, 0, PAGE_SIZE, 0, 0);
130         if (IS_ERR_VALUE(addr)) {
131                 ret = addr;
132                 goto up_fail;
133         }
134
135         vma = kmem_cache_zalloc(vm_area_cachep, GFP_KERNEL);
136         if (!vma) {
137                 ret = -ENOMEM;
138                 goto up_fail;
139         }
140
141         vma->vm_start = addr;
142         vma->vm_end = addr + PAGE_SIZE;
143         /* MAYWRITE to allow gdb to COW and set breakpoints */
144         vma->vm_flags = VM_READ|VM_EXEC|VM_MAYREAD|VM_MAYEXEC|VM_MAYWRITE;
145         /*
146          * Make sure the vDSO gets into every core dump.
147          * Dumping its contents makes post-mortem fully interpretable later
148          * without matching up the same kernel and hardware config to see
149          * what PC values meant.
150          */
151         vma->vm_flags |= VM_ALWAYSDUMP;
152         vma->vm_flags |= mm->def_flags;
153         vma->vm_page_prot = protection_map[vma->vm_flags & 7];
154         vma->vm_ops = &syscall_vm_ops;
155         vma->vm_mm = mm;
156
157         ret = insert_vm_struct(mm, vma);
158         if (unlikely(ret)) {
159                 kmem_cache_free(vm_area_cachep, vma);
160                 goto up_fail;
161         }
162
163         current->mm->context.vdso = (void *)addr;
164         current_thread_info()->sysenter_return =
165                                     (void *)VDSO_SYM(&SYSENTER_RETURN);
166         mm->total_vm++;
167 up_fail:
168         up_write(&mm->mmap_sem);
169         return ret;
170 }
171
172 const char *arch_vma_name(struct vm_area_struct *vma)
173 {
174         if (vma->vm_mm && vma->vm_start == (long)vma->vm_mm->context.vdso)
175                 return "[vdso]";
176         return NULL;
177 }
178
179 struct vm_area_struct *get_gate_vma(struct task_struct *tsk)
180 {
181         return NULL;
182 }
183
184 int in_gate_area(struct task_struct *task, unsigned long addr)
185 {
186         return 0;
187 }
188
189 int in_gate_area_no_task(unsigned long addr)
190 {
191         return 0;
192 }
193 #endif