forked from Minki/linux
4c9fff3622
If the DTB is located in the target memory area for the relocated kernel it needs to be relocated as well before kernel relocation takes place. After copying the DTB use the new plat_fdt_relocated() API from the relocated kernel to ensure the relocated kernel updates any information that it may have cached about the location of the DTB. plat_fdt_relocated is declared as a weak symbol so that platforms that do not require it do not need to implement the method. Signed-off-by: Marcin Nowakowski <marcin.nowakowski@imgtec.com> Cc: linux-mips@linux-mips.org Patchwork: https://patchwork.linux-mips.org/patch/14616/ Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
441 lines
11 KiB
C
441 lines
11 KiB
C
/*
|
|
* This file is subject to the terms and conditions of the GNU General Public
|
|
* License. See the file "COPYING" in the main directory of this archive
|
|
* for more details.
|
|
*
|
|
* Support for Kernel relocation at boot time
|
|
*
|
|
* Copyright (C) 2015, Imagination Technologies Ltd.
|
|
* Authors: Matt Redfearn (matt.redfearn@imgtec.com)
|
|
*/
|
|
#include <asm/bootinfo.h>
|
|
#include <asm/cacheflush.h>
|
|
#include <asm/fw/fw.h>
|
|
#include <asm/sections.h>
|
|
#include <asm/setup.h>
|
|
#include <asm/timex.h>
|
|
#include <linux/elf.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/libfdt.h>
|
|
#include <linux/of_fdt.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/start_kernel.h>
|
|
#include <linux/string.h>
|
|
#include <linux/printk.h>
|
|
|
|
#define RELOCATED(x) ((void *)((long)x + offset))
|
|
|
|
extern u32 _relocation_start[]; /* End kernel image / start relocation table */
|
|
extern u32 _relocation_end[]; /* End relocation table */
|
|
|
|
extern long __start___ex_table; /* Start exception table */
|
|
extern long __stop___ex_table; /* End exception table */
|
|
|
|
extern void __weak plat_fdt_relocated(void *new_location);
|
|
|
|
/*
|
|
* This function may be defined for a platform to perform any post-relocation
|
|
* fixup necessary.
|
|
* Return non-zero to abort relocation
|
|
*/
|
|
int __weak plat_post_relocation(long offset)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline u32 __init get_synci_step(void)
|
|
{
|
|
u32 res;
|
|
|
|
__asm__("rdhwr %0, $1" : "=r" (res));
|
|
|
|
return res;
|
|
}
|
|
|
|
static void __init sync_icache(void *kbase, unsigned long kernel_length)
|
|
{
|
|
void *kend = kbase + kernel_length;
|
|
u32 step = get_synci_step();
|
|
|
|
do {
|
|
__asm__ __volatile__(
|
|
"synci 0(%0)"
|
|
: /* no output */
|
|
: "r" (kbase));
|
|
|
|
kbase += step;
|
|
} while (kbase < kend);
|
|
|
|
/* Completion barrier */
|
|
__sync();
|
|
}
|
|
|
|
static int __init apply_r_mips_64_rel(u32 *loc_orig, u32 *loc_new, long offset)
|
|
{
|
|
*(u64 *)loc_new += offset;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int __init apply_r_mips_32_rel(u32 *loc_orig, u32 *loc_new, long offset)
|
|
{
|
|
*loc_new += offset;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int __init apply_r_mips_26_rel(u32 *loc_orig, u32 *loc_new, long offset)
|
|
{
|
|
unsigned long target_addr = (*loc_orig) & 0x03ffffff;
|
|
|
|
if (offset % 4) {
|
|
pr_err("Dangerous R_MIPS_26 REL relocation\n");
|
|
return -ENOEXEC;
|
|
}
|
|
|
|
/* Original target address */
|
|
target_addr <<= 2;
|
|
target_addr += (unsigned long)loc_orig & ~0x03ffffff;
|
|
|
|
/* Get the new target address */
|
|
target_addr += offset;
|
|
|
|
if ((target_addr & 0xf0000000) != ((unsigned long)loc_new & 0xf0000000)) {
|
|
pr_err("R_MIPS_26 REL relocation overflow\n");
|
|
return -ENOEXEC;
|
|
}
|
|
|
|
target_addr -= (unsigned long)loc_new & ~0x03ffffff;
|
|
target_addr >>= 2;
|
|
|
|
*loc_new = (*loc_new & ~0x03ffffff) | (target_addr & 0x03ffffff);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int __init apply_r_mips_hi16_rel(u32 *loc_orig, u32 *loc_new, long offset)
|
|
{
|
|
unsigned long insn = *loc_orig;
|
|
unsigned long target = (insn & 0xffff) << 16; /* high 16bits of target */
|
|
|
|
target += offset;
|
|
|
|
*loc_new = (insn & ~0xffff) | ((target >> 16) & 0xffff);
|
|
return 0;
|
|
}
|
|
|
|
static int (*reloc_handlers_rel[]) (u32 *, u32 *, long) __initdata = {
|
|
[R_MIPS_64] = apply_r_mips_64_rel,
|
|
[R_MIPS_32] = apply_r_mips_32_rel,
|
|
[R_MIPS_26] = apply_r_mips_26_rel,
|
|
[R_MIPS_HI16] = apply_r_mips_hi16_rel,
|
|
};
|
|
|
|
int __init do_relocations(void *kbase_old, void *kbase_new, long offset)
|
|
{
|
|
u32 *r;
|
|
u32 *loc_orig;
|
|
u32 *loc_new;
|
|
int type;
|
|
int res;
|
|
|
|
for (r = _relocation_start; r < _relocation_end; r++) {
|
|
/* Sentinel for last relocation */
|
|
if (*r == 0)
|
|
break;
|
|
|
|
type = (*r >> 24) & 0xff;
|
|
loc_orig = (void *)(kbase_old + ((*r & 0x00ffffff) << 2));
|
|
loc_new = RELOCATED(loc_orig);
|
|
|
|
if (reloc_handlers_rel[type] == NULL) {
|
|
/* Unsupported relocation */
|
|
pr_err("Unhandled relocation type %d at 0x%pK\n",
|
|
type, loc_orig);
|
|
return -ENOEXEC;
|
|
}
|
|
|
|
res = reloc_handlers_rel[type](loc_orig, loc_new, offset);
|
|
if (res)
|
|
return res;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* The exception table is filled in by the relocs tool after vmlinux is linked.
|
|
* It must be relocated separately since there will not be any relocation
|
|
* information for it filled in by the linker.
|
|
*/
|
|
static int __init relocate_exception_table(long offset)
|
|
{
|
|
unsigned long *etable_start, *etable_end, *e;
|
|
|
|
etable_start = RELOCATED(&__start___ex_table);
|
|
etable_end = RELOCATED(&__stop___ex_table);
|
|
|
|
for (e = etable_start; e < etable_end; e++)
|
|
*e += offset;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_RANDOMIZE_BASE
|
|
|
|
static inline __init unsigned long rotate_xor(unsigned long hash,
|
|
const void *area, size_t size)
|
|
{
|
|
size_t i;
|
|
unsigned long *ptr = (unsigned long *)area;
|
|
|
|
for (i = 0; i < size / sizeof(hash); i++) {
|
|
/* Rotate by odd number of bits and XOR. */
|
|
hash = (hash << ((sizeof(hash) * 8) - 7)) | (hash >> 7);
|
|
hash ^= ptr[i];
|
|
}
|
|
|
|
return hash;
|
|
}
|
|
|
|
static inline __init unsigned long get_random_boot(void)
|
|
{
|
|
unsigned long entropy = random_get_entropy();
|
|
unsigned long hash = 0;
|
|
|
|
/* Attempt to create a simple but unpredictable starting entropy. */
|
|
hash = rotate_xor(hash, linux_banner, strlen(linux_banner));
|
|
|
|
/* Add in any runtime entropy we can get */
|
|
hash = rotate_xor(hash, &entropy, sizeof(entropy));
|
|
|
|
#if defined(CONFIG_USE_OF)
|
|
/* Get any additional entropy passed in device tree */
|
|
if (initial_boot_params) {
|
|
int node, len;
|
|
u64 *prop;
|
|
|
|
node = fdt_path_offset(initial_boot_params, "/chosen");
|
|
if (node >= 0) {
|
|
prop = fdt_getprop_w(initial_boot_params, node,
|
|
"kaslr-seed", &len);
|
|
if (prop && (len == sizeof(u64)))
|
|
hash = rotate_xor(hash, prop, sizeof(*prop));
|
|
}
|
|
}
|
|
#endif /* CONFIG_USE_OF */
|
|
|
|
return hash;
|
|
}
|
|
|
|
static inline __init bool kaslr_disabled(void)
|
|
{
|
|
char *str;
|
|
|
|
#if defined(CONFIG_CMDLINE_BOOL)
|
|
const char *builtin_cmdline = CONFIG_CMDLINE;
|
|
|
|
str = strstr(builtin_cmdline, "nokaslr");
|
|
if (str == builtin_cmdline ||
|
|
(str > builtin_cmdline && *(str - 1) == ' '))
|
|
return true;
|
|
#endif
|
|
str = strstr(arcs_cmdline, "nokaslr");
|
|
if (str == arcs_cmdline || (str > arcs_cmdline && *(str - 1) == ' '))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
static inline void __init *determine_relocation_address(void)
|
|
{
|
|
/* Choose a new address for the kernel */
|
|
unsigned long kernel_length;
|
|
void *dest = &_text;
|
|
unsigned long offset;
|
|
|
|
if (kaslr_disabled())
|
|
return dest;
|
|
|
|
kernel_length = (long)_end - (long)(&_text);
|
|
|
|
offset = get_random_boot() << 16;
|
|
offset &= (CONFIG_RANDOMIZE_BASE_MAX_OFFSET - 1);
|
|
if (offset < kernel_length)
|
|
offset += ALIGN(kernel_length, 0xffff);
|
|
|
|
return RELOCATED(dest);
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void __init *determine_relocation_address(void)
|
|
{
|
|
/*
|
|
* Choose a new address for the kernel
|
|
* For now we'll hard code the destination
|
|
*/
|
|
return (void *)0xffffffff81000000;
|
|
}
|
|
|
|
#endif
|
|
|
|
static inline int __init relocation_addr_valid(void *loc_new)
|
|
{
|
|
if ((unsigned long)loc_new & 0x0000ffff) {
|
|
/* Inappropriately aligned new location */
|
|
return 0;
|
|
}
|
|
if ((unsigned long)loc_new < (unsigned long)&_end) {
|
|
/* New location overlaps original kernel */
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void *__init relocate_kernel(void)
|
|
{
|
|
void *loc_new;
|
|
unsigned long kernel_length;
|
|
unsigned long bss_length;
|
|
long offset = 0;
|
|
int res = 1;
|
|
/* Default to original kernel entry point */
|
|
void *kernel_entry = start_kernel;
|
|
void *fdt = NULL;
|
|
|
|
/* Get the command line */
|
|
fw_init_cmdline();
|
|
#if defined(CONFIG_USE_OF)
|
|
/* Deal with the device tree */
|
|
fdt = plat_get_fdt();
|
|
early_init_dt_scan(fdt);
|
|
if (boot_command_line[0]) {
|
|
/* Boot command line was passed in device tree */
|
|
strlcpy(arcs_cmdline, boot_command_line, COMMAND_LINE_SIZE);
|
|
}
|
|
#endif /* CONFIG_USE_OF */
|
|
|
|
kernel_length = (long)(&_relocation_start) - (long)(&_text);
|
|
bss_length = (long)&__bss_stop - (long)&__bss_start;
|
|
|
|
loc_new = determine_relocation_address();
|
|
|
|
/* Sanity check relocation address */
|
|
if (relocation_addr_valid(loc_new))
|
|
offset = (unsigned long)loc_new - (unsigned long)(&_text);
|
|
|
|
/* Reset the command line now so we don't end up with a duplicate */
|
|
arcs_cmdline[0] = '\0';
|
|
|
|
if (offset) {
|
|
void (*fdt_relocated_)(void *) = NULL;
|
|
#if defined(CONFIG_USE_OF)
|
|
unsigned long fdt_phys = virt_to_phys(fdt);
|
|
|
|
/*
|
|
* If built-in dtb is used then it will have been relocated
|
|
* during kernel _text relocation. If appended DTB is used
|
|
* then it will not be relocated, but it should remain
|
|
* intact in the original location. If dtb is loaded by
|
|
* the bootloader then it may need to be moved if it crosses
|
|
* the target memory area
|
|
*/
|
|
|
|
if (fdt_phys >= virt_to_phys(RELOCATED(&_text)) &&
|
|
fdt_phys <= virt_to_phys(RELOCATED(&_end))) {
|
|
void *fdt_relocated =
|
|
RELOCATED(ALIGN((long)&_end, PAGE_SIZE));
|
|
memcpy(fdt_relocated, fdt, fdt_totalsize(fdt));
|
|
fdt = fdt_relocated;
|
|
fdt_relocated_ = RELOCATED(&plat_fdt_relocated);
|
|
}
|
|
#endif /* CONFIG_USE_OF */
|
|
|
|
/* Copy the kernel to it's new location */
|
|
memcpy(loc_new, &_text, kernel_length);
|
|
|
|
/* Perform relocations on the new kernel */
|
|
res = do_relocations(&_text, loc_new, offset);
|
|
if (res < 0)
|
|
goto out;
|
|
|
|
/* Sync the caches ready for execution of new kernel */
|
|
sync_icache(loc_new, kernel_length);
|
|
|
|
res = relocate_exception_table(offset);
|
|
if (res < 0)
|
|
goto out;
|
|
|
|
/*
|
|
* The original .bss has already been cleared, and
|
|
* some variables such as command line parameters
|
|
* stored to it so make a copy in the new location.
|
|
*/
|
|
memcpy(RELOCATED(&__bss_start), &__bss_start, bss_length);
|
|
|
|
/*
|
|
* If fdt was stored outside of the kernel image and
|
|
* had to be moved then update platform's state data
|
|
* with the new fdt location
|
|
*/
|
|
if (fdt_relocated_)
|
|
fdt_relocated_(fdt);
|
|
|
|
/*
|
|
* Last chance for the platform to abort relocation.
|
|
* This may also be used by the platform to perform any
|
|
* initialisation required now that the new kernel is
|
|
* resident in memory and ready to be executed.
|
|
*/
|
|
if (plat_post_relocation(offset))
|
|
goto out;
|
|
|
|
/* The current thread is now within the relocated image */
|
|
__current_thread_info = RELOCATED(&init_thread_union);
|
|
|
|
/* Return the new kernel's entry point */
|
|
kernel_entry = RELOCATED(start_kernel);
|
|
}
|
|
out:
|
|
return kernel_entry;
|
|
}
|
|
|
|
/*
|
|
* Show relocation information on panic.
|
|
*/
|
|
void show_kernel_relocation(const char *level)
|
|
{
|
|
unsigned long offset;
|
|
|
|
offset = __pa_symbol(_text) - __pa_symbol(VMLINUX_LOAD_ADDRESS);
|
|
|
|
if (IS_ENABLED(CONFIG_RELOCATABLE) && offset > 0) {
|
|
printk(level);
|
|
pr_cont("Kernel relocated by 0x%pK\n", (void *)offset);
|
|
pr_cont(" .text @ 0x%pK\n", _text);
|
|
pr_cont(" .data @ 0x%pK\n", _sdata);
|
|
pr_cont(" .bss @ 0x%pK\n", __bss_start);
|
|
}
|
|
}
|
|
|
|
static int kernel_location_notifier_fn(struct notifier_block *self,
|
|
unsigned long v, void *p)
|
|
{
|
|
show_kernel_relocation(KERN_EMERG);
|
|
return NOTIFY_DONE;
|
|
}
|
|
|
|
static struct notifier_block kernel_location_notifier = {
|
|
.notifier_call = kernel_location_notifier_fn
|
|
};
|
|
|
|
static int __init register_kernel_offset_dumper(void)
|
|
{
|
|
atomic_notifier_chain_register(&panic_notifier_list,
|
|
&kernel_location_notifier);
|
|
return 0;
|
|
}
|
|
__initcall(register_kernel_offset_dumper);
|