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 unsigned int __read_mostly vdso_enabled = 1;
  31
  32 EXPORT_SYMBOL_GPL(vdso_enabled);
  33
  34 static int __init vdso_setup(char *s)
  35 {
  36         vdso_enabled = simple_strtoul(s, NULL, 0);
  37
  38         return 1;
  39 }
  40
  41 __setup("vdso=", vdso_setup);
  42
  43 extern asmlinkage void sysenter_entry(void);
  44
  45 void enable_sep_cpu(void)
  46 {
  47         int cpu = get_cpu();
  48         struct tss_struct *tss = &per_cpu(init_tss, cpu);
  49
  50         if (!boot_cpu_has(X86_FEATURE_SEP)) {
  51                 put_cpu();
  52                 return;
  53         }
  54
  55         tss->ss1 = __KERNEL_CS;
  56         tss->esp1 = sizeof(struct tss_struct) + (unsigned long) tss;
  57         wrmsr(MSR_IA32_SYSENTER_CS, __KERNEL_CS, 0);
  58         wrmsr(MSR_IA32_SYSENTER_ESP, tss->esp1, 0);
  59         wrmsr(MSR_IA32_SYSENTER_EIP, (unsigned long) sysenter_entry, 0);
  60         put_cpu();
  61 }
  62
  63 /*
  64  * These symbols are defined by vsyscall.o to mark the bounds
  65  * of the ELF DSO images included therein.
  66  */
  67 extern const char vsyscall_int80_start, vsyscall_int80_end;
  68 extern const char vsyscall_sysenter_start, vsyscall_sysenter_end;
  69 static void *syscall_page;
  70
  71 int __init sysenter_setup(void)
  72 {
  73         syscall_page = (void *)get_zeroed_page(GFP_ATOMIC);
  74
  75 #ifdef CONFIG_COMPAT_VDSO
  76         __set_fixmap(FIX_VDSO, __pa(syscall_page), PAGE_READONLY);
  77         printk("Compat vDSO mapped to %08lx.\n", __fix_to_virt(FIX_VDSO));
  78 #else
  79         /*
  80          * In the non-compat case the ELF coredumping code needs the fixmap:
  81          */
  82         __set_fixmap(FIX_VDSO, __pa(syscall_page), PAGE_KERNEL_RO);
  83 #endif
  84
  85         if (!boot_cpu_has(X86_FEATURE_SEP)) {
  86                 memcpy(syscall_page,
  87                        &vsyscall_int80_start,
  88                        &vsyscall_int80_end - &vsyscall_int80_start);
  89                 return 0;
  90         }
  91
  92         memcpy(syscall_page,
  93                &vsyscall_sysenter_start,
  94                &vsyscall_sysenter_end - &vsyscall_sysenter_start);
  95
  96         return 0;
  97 }
  98
  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, SLAB_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         vma->vm_flags |= mm->def_flags;
 146         vma->vm_page_prot = protection_map[vma->vm_flags & 7];
 147         vma->vm_ops = &syscall_vm_ops;
 148         vma->vm_mm = mm;
 149
 150         ret = insert_vm_struct(mm, vma);
 151         if (unlikely(ret)) {
 152                 kmem_cache_free(vm_area_cachep, vma);
 153                 goto up_fail;
 154         }
 155
 156         current->mm->context.vdso = (void *)addr;
 157         current_thread_info()->sysenter_return =
 158                                     (void *)VDSO_SYM(&SYSENTER_RETURN);
 159         mm->total_vm++;
 160 up_fail:
 161         up_write(&mm->mmap_sem);
 162         return ret;
 163 }
 164
 165 const char *arch_vma_name(struct vm_area_struct *vma)
 166 {
 167         if (vma->vm_mm && vma->vm_start == (long)vma->vm_mm->context.vdso)
 168                 return "[vdso]";
 169         return NULL;
 170 }
 171
 172 struct vm_area_struct *get_gate_vma(struct task_struct *tsk)
 173 {
 174         return NULL;
 175 }
 176
 177 int in_gate_area(struct task_struct *task, unsigned long addr)
 178 {
 179         return 0;
 180 }
 181
 182 int in_gate_area_no_task(unsigned long addr)
 183 {
 184         return 0;
 185 }