Contributors: 12
| Author |
Tokens |
Token Proportion |
Commits |
Commit Proportion |
| Nagarathnam Muthusamy |
697 |
86.91% |
1 |
4.35% |
| Thomas Weißschuh |
36 |
4.49% |
1 |
4.35% |
| Pavel Tatashin |
25 |
3.12% |
2 |
8.70% |
| Linus Torvalds (pre-git) |
15 |
1.87% |
8 |
34.78% |
| David S. Miller |
12 |
1.50% |
3 |
13.04% |
| Dan Carpenter |
4 |
0.50% |
1 |
4.35% |
| Jason A. Donenfeld |
3 |
0.37% |
2 |
8.70% |
| Kees Cook |
3 |
0.37% |
1 |
4.35% |
| Michel Lespinasse |
2 |
0.25% |
1 |
4.35% |
| Randy Dunlap |
2 |
0.25% |
1 |
4.35% |
| Thomas Gleixner |
2 |
0.25% |
1 |
4.35% |
| Sam Ravnborg |
1 |
0.12% |
1 |
4.35% |
| Total |
802 |
|
23 |
|
// SPDX-License-Identifier: GPL-2.0-only
/*
* Set up the VMAs to tell the VM about the vDSO.
* Copyright 2007 Andi Kleen, SUSE Labs.
*/
/*
* Copyright (c) 2017 Oracle and/or its affiliates. All rights reserved.
*/
#include <linux/mm.h>
#include <linux/err.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/linkage.h>
#include <linux/random.h>
#include <linux/elf.h>
#include <linux/vdso_datastore.h>
#include <asm/cacheflush.h>
#include <asm/spitfire.h>
#include <asm/vdso.h>
#include <asm/page.h>
#include <vdso/datapage.h>
#include <asm/vdso/vsyscall.h>
unsigned int __read_mostly vdso_enabled = 1;
#ifdef CONFIG_SPARC64
static struct vm_special_mapping vdso_mapping64 = {
.name = "[vdso]"
};
#endif
#ifdef CONFIG_COMPAT
static struct vm_special_mapping vdso_mapping32 = {
.name = "[vdso]"
};
#endif
/*
* Allocate pages for the vdso and copy in the vdso text from the
* kernel image.
*/
static int __init init_vdso_image(const struct vdso_image *image,
struct vm_special_mapping *vdso_mapping,
bool elf64)
{
int cnpages = (image->size) / PAGE_SIZE;
struct page *cp, **cpp = NULL;
int i;
/*
* First, the vdso text. This is initialied data, an integral number of
* pages long.
*/
if (WARN_ON(image->size % PAGE_SIZE != 0))
goto oom;
cpp = kzalloc_objs(struct page *, cnpages);
vdso_mapping->pages = cpp;
if (!cpp)
goto oom;
for (i = 0; i < cnpages; i++) {
cp = alloc_page(GFP_KERNEL);
if (!cp)
goto oom;
cpp[i] = cp;
copy_page(page_address(cp), image->data + i * PAGE_SIZE);
}
return 0;
oom:
if (cpp != NULL) {
for (i = 0; i < cnpages; i++) {
if (cpp[i] != NULL)
__free_page(cpp[i]);
}
kfree(cpp);
vdso_mapping->pages = NULL;
}
pr_warn("Cannot allocate vdso\n");
vdso_enabled = 0;
return -ENOMEM;
}
static int __init init_vdso(void)
{
int err = 0;
#ifdef CONFIG_SPARC64
err = init_vdso_image(&vdso_image_64_builtin, &vdso_mapping64, true);
if (err)
return err;
#endif
#ifdef CONFIG_COMPAT
err = init_vdso_image(&vdso_image_32_builtin, &vdso_mapping32, false);
#endif
return err;
}
subsys_initcall(init_vdso);
struct linux_binprm;
/* Shuffle the vdso up a bit, randomly. */
static unsigned long vdso_addr(unsigned long start, unsigned int len)
{
unsigned int offset;
/* This loses some more bits than a modulo, but is cheaper */
offset = get_random_u32_below(PTRS_PER_PTE);
return start + (offset << PAGE_SHIFT);
}
static_assert(VDSO_NR_PAGES == __VDSO_PAGES);
static int map_vdso(const struct vdso_image *image,
struct vm_special_mapping *vdso_mapping)
{
const size_t area_size = image->size + VDSO_NR_PAGES * PAGE_SIZE;
struct mm_struct *mm = current->mm;
struct vm_area_struct *vma;
unsigned long text_start, addr = 0;
int ret = 0;
mmap_write_lock(mm);
/*
* First, get an unmapped region: then randomize it, and make sure that
* region is free.
*/
if (current->flags & PF_RANDOMIZE) {
addr = get_unmapped_area(NULL, 0, area_size, 0, 0);
if (IS_ERR_VALUE(addr)) {
ret = addr;
goto up_fail;
}
addr = vdso_addr(addr, area_size);
}
addr = get_unmapped_area(NULL, addr, area_size, 0, 0);
if (IS_ERR_VALUE(addr)) {
ret = addr;
goto up_fail;
}
text_start = addr + VDSO_NR_PAGES * PAGE_SIZE;
current->mm->context.vdso = (void __user *)text_start;
/*
* MAYWRITE to allow gdb to COW and set breakpoints
*/
vma = _install_special_mapping(mm,
text_start,
image->size,
VM_READ|VM_EXEC|
VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC,
vdso_mapping);
if (IS_ERR(vma)) {
ret = PTR_ERR(vma);
goto up_fail;
}
vma = vdso_install_vvar_mapping(mm, addr);
if (IS_ERR(vma)) {
ret = PTR_ERR(vma);
do_munmap(mm, text_start, image->size, NULL);
}
up_fail:
if (ret)
current->mm->context.vdso = NULL;
mmap_write_unlock(mm);
return ret;
}
int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
{
if (!vdso_enabled)
return 0;
#if defined CONFIG_COMPAT
if (!(is_32bit_task()))
return map_vdso(&vdso_image_64_builtin, &vdso_mapping64);
else
return map_vdso(&vdso_image_32_builtin, &vdso_mapping32);
#else
return map_vdso(&vdso_image_64_builtin, &vdso_mapping64);
#endif
}
static __init int vdso_setup(char *s)
{
int err;
unsigned long val;
err = kstrtoul(s, 10, &val);
if (!err)
vdso_enabled = val;
return 1;
}
__setup("vdso=", vdso_setup);