mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-02 12:16:41 +07:00
e34eb39c1c
* 'x86-cpu-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: x86, amd: Include linux/elf.h since we use stuff from asm/elf.h x86: cache_info: Update calculation of AMD L3 cache indices x86: cache_info: Kill the atomic allocation in amd_init_l3_cache() x86: cache_info: Kill the moronic shadow struct x86: cache_info: Remove bogus free of amd_l3_cache data x86, amd: Include elf.h explicitly, prepare the code for the module.h split x86-32, amd: Move va_align definition to unbreak 32-bit build x86, amd: Move BSP code to cpu_dev helper x86: Add a BSP cpu_dev helper x86, amd: Avoid cache aliasing penalties on AMD family 15h
146 lines
3.5 KiB
C
146 lines
3.5 KiB
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/slab.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 <asm/page.h>
|
|
|
|
unsigned int __read_mostly vdso_enabled = 1;
|
|
|
|
extern char vdso_start[], vdso_end[];
|
|
extern unsigned short vdso_sync_cpuid;
|
|
|
|
extern struct page *vdso_pages[];
|
|
static unsigned vdso_size;
|
|
|
|
static void __init patch_vdso(void *vdso, size_t len)
|
|
{
|
|
Elf64_Ehdr *hdr = vdso;
|
|
Elf64_Shdr *sechdrs, *alt_sec = 0;
|
|
char *secstrings;
|
|
void *alt_data;
|
|
int i;
|
|
|
|
BUG_ON(len < sizeof(Elf64_Ehdr));
|
|
BUG_ON(memcmp(hdr->e_ident, ELFMAG, SELFMAG) != 0);
|
|
|
|
sechdrs = (void *)hdr + hdr->e_shoff;
|
|
secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
|
|
|
|
for (i = 1; i < hdr->e_shnum; i++) {
|
|
Elf64_Shdr *shdr = &sechdrs[i];
|
|
if (!strcmp(secstrings + shdr->sh_name, ".altinstructions")) {
|
|
alt_sec = shdr;
|
|
goto found;
|
|
}
|
|
}
|
|
|
|
/* If we get here, it's probably a bug. */
|
|
pr_warning("patch_vdso: .altinstructions not found\n");
|
|
return; /* nothing to patch */
|
|
|
|
found:
|
|
alt_data = (void *)hdr + alt_sec->sh_offset;
|
|
apply_alternatives(alt_data, alt_data + alt_sec->sh_size);
|
|
}
|
|
|
|
static int __init init_vdso(void)
|
|
{
|
|
int npages = (vdso_end - vdso_start + PAGE_SIZE - 1) / PAGE_SIZE;
|
|
int i;
|
|
|
|
patch_vdso(vdso_start, vdso_end - vdso_start);
|
|
|
|
vdso_size = npages << PAGE_SHIFT;
|
|
for (i = 0; i < npages; i++)
|
|
vdso_pages[i] = virt_to_page(vdso_start + i*PAGE_SIZE);
|
|
|
|
return 0;
|
|
}
|
|
subsys_initcall(init_vdso);
|
|
|
|
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;
|
|
|
|
/*
|
|
* page-align it here so that get_unmapped_area doesn't
|
|
* align it wrongfully again to the next page. addr can come in 4K
|
|
* unaligned here as a result of stack start randomization.
|
|
*/
|
|
addr = PAGE_ALIGN(addr);
|
|
addr = align_addr(addr, NULL, ALIGN_VDSO);
|
|
|
|
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;
|
|
}
|
|
|
|
current->mm->context.vdso = (void *)addr;
|
|
|
|
ret = install_special_mapping(mm, addr, vdso_size,
|
|
VM_READ|VM_EXEC|
|
|
VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC|
|
|
VM_ALWAYSDUMP,
|
|
vdso_pages);
|
|
if (ret) {
|
|
current->mm->context.vdso = NULL;
|
|
goto up_fail;
|
|
}
|
|
|
|
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);
|