linux/arch/mips/kernel/relocate.c
<<
>>
Prefs
   1/*
   2 * This file is subject to the terms and conditions of the GNU General Public
   3 * License.  See the file "COPYING" in the main directory of this archive
   4 * for more details.
   5 *
   6 * Support for Kernel relocation at boot time
   7 *
   8 * Copyright (C) 2015, Imagination Technologies Ltd.
   9 * Authors: Matt Redfearn (matt.redfearn@mips.com)
  10 */
  11#include <asm/bootinfo.h>
  12#include <asm/cacheflush.h>
  13#include <asm/fw/fw.h>
  14#include <asm/sections.h>
  15#include <asm/setup.h>
  16#include <asm/timex.h>
  17#include <linux/elf.h>
  18#include <linux/kernel.h>
  19#include <linux/libfdt.h>
  20#include <linux/of_fdt.h>
  21#include <linux/sched/task.h>
  22#include <linux/start_kernel.h>
  23#include <linux/string.h>
  24#include <linux/printk.h>
  25
  26#define RELOCATED(x) ((void *)((long)x + offset))
  27
  28extern u32 _relocation_start[]; /* End kernel image / start relocation table */
  29extern u32 _relocation_end[];   /* End relocation table */
  30
  31extern long __start___ex_table; /* Start exception table */
  32extern long __stop___ex_table;  /* End exception table */
  33
  34extern void __weak plat_fdt_relocated(void *new_location);
  35
  36/*
  37 * This function may be defined for a platform to perform any post-relocation
  38 * fixup necessary.
  39 * Return non-zero to abort relocation
  40 */
  41int __weak plat_post_relocation(long offset)
  42{
  43        return 0;
  44}
  45
  46static inline u32 __init get_synci_step(void)
  47{
  48        u32 res;
  49
  50        __asm__("rdhwr  %0, $1" : "=r" (res));
  51
  52        return res;
  53}
  54
  55static void __init sync_icache(void *kbase, unsigned long kernel_length)
  56{
  57        void *kend = kbase + kernel_length;
  58        u32 step = get_synci_step();
  59
  60        do {
  61                __asm__ __volatile__(
  62                        "synci  0(%0)"
  63                        : /* no output */
  64                        : "r" (kbase));
  65
  66                kbase += step;
  67        } while (step && kbase < kend);
  68
  69        /* Completion barrier */
  70        __sync();
  71}
  72
  73static void __init apply_r_mips_64_rel(u32 *loc_new, long offset)
  74{
  75        *(u64 *)loc_new += offset;
  76}
  77
  78static void __init apply_r_mips_32_rel(u32 *loc_new, long offset)
  79{
  80        *loc_new += offset;
  81}
  82
  83static int __init apply_r_mips_26_rel(u32 *loc_orig, u32 *loc_new, long offset)
  84{
  85        unsigned long target_addr = (*loc_orig) & 0x03ffffff;
  86
  87        if (offset % 4) {
  88                pr_err("Dangerous R_MIPS_26 REL relocation\n");
  89                return -ENOEXEC;
  90        }
  91
  92        /* Original target address */
  93        target_addr <<= 2;
  94        target_addr += (unsigned long)loc_orig & 0xf0000000;
  95
  96        /* Get the new target address */
  97        target_addr += offset;
  98
  99        if ((target_addr & 0xf0000000) != ((unsigned long)loc_new & 0xf0000000)) {
 100                pr_err("R_MIPS_26 REL relocation overflow\n");
 101                return -ENOEXEC;
 102        }
 103
 104        target_addr -= (unsigned long)loc_new & 0xf0000000;
 105        target_addr >>= 2;
 106
 107        *loc_new = (*loc_new & ~0x03ffffff) | (target_addr & 0x03ffffff);
 108
 109        return 0;
 110}
 111
 112
 113static void __init apply_r_mips_hi16_rel(u32 *loc_orig, u32 *loc_new,
 114                                         long offset)
 115{
 116        unsigned long insn = *loc_orig;
 117        unsigned long target = (insn & 0xffff) << 16; /* high 16bits of target */
 118
 119        target += offset;
 120
 121        *loc_new = (insn & ~0xffff) | ((target >> 16) & 0xffff);
 122}
 123
 124static int __init reloc_handler(u32 type, u32 *loc_orig, u32 *loc_new,
 125                                long offset)
 126{
 127        switch (type) {
 128        case R_MIPS_64:
 129                apply_r_mips_64_rel(loc_new, offset);
 130                break;
 131        case R_MIPS_32:
 132                apply_r_mips_32_rel(loc_new, offset);
 133                break;
 134        case R_MIPS_26:
 135                return apply_r_mips_26_rel(loc_orig, loc_new, offset);
 136        case R_MIPS_HI16:
 137                apply_r_mips_hi16_rel(loc_orig, loc_new, offset);
 138                break;
 139        default:
 140                pr_err("Unhandled relocation type %d at 0x%pK\n", type,
 141                       loc_orig);
 142                return -ENOEXEC;
 143        }
 144
 145        return 0;
 146}
 147
 148static int __init do_relocations(void *kbase_old, void *kbase_new, long offset)
 149{
 150        u32 *r;
 151        u32 *loc_orig;
 152        u32 *loc_new;
 153        int type;
 154        int res;
 155
 156        for (r = _relocation_start; r < _relocation_end; r++) {
 157                /* Sentinel for last relocation */
 158                if (*r == 0)
 159                        break;
 160
 161                type = (*r >> 24) & 0xff;
 162                loc_orig = kbase_old + ((*r & 0x00ffffff) << 2);
 163                loc_new = RELOCATED(loc_orig);
 164
 165                res = reloc_handler(type, loc_orig, loc_new, offset);
 166                if (res)
 167                        return res;
 168        }
 169
 170        return 0;
 171}
 172
 173/*
 174 * The exception table is filled in by the relocs tool after vmlinux is linked.
 175 * It must be relocated separately since there will not be any relocation
 176 * information for it filled in by the linker.
 177 */
 178static int __init relocate_exception_table(long offset)
 179{
 180        unsigned long *etable_start, *etable_end, *e;
 181
 182        etable_start = RELOCATED(&__start___ex_table);
 183        etable_end = RELOCATED(&__stop___ex_table);
 184
 185        for (e = etable_start; e < etable_end; e++)
 186                *e += offset;
 187
 188        return 0;
 189}
 190
 191#ifdef CONFIG_RANDOMIZE_BASE
 192
 193static inline __init unsigned long rotate_xor(unsigned long hash,
 194                                              const void *area, size_t size)
 195{
 196        const typeof(hash) *ptr = PTR_ALIGN(area, sizeof(hash));
 197        size_t diff, i;
 198
 199        diff = (void *)ptr - area;
 200        if (unlikely(size < diff + sizeof(hash)))
 201                return hash;
 202
 203        size = ALIGN_DOWN(size - diff, sizeof(hash));
 204
 205        for (i = 0; i < size / sizeof(hash); i++) {
 206                /* Rotate by odd number of bits and XOR. */
 207                hash = (hash << ((sizeof(hash) * 8) - 7)) | (hash >> 7);
 208                hash ^= ptr[i];
 209        }
 210
 211        return hash;
 212}
 213
 214static inline __init unsigned long get_random_boot(void)
 215{
 216        unsigned long entropy = random_get_entropy();
 217        unsigned long hash = 0;
 218
 219        /* Attempt to create a simple but unpredictable starting entropy. */
 220        hash = rotate_xor(hash, linux_banner, strlen(linux_banner));
 221
 222        /* Add in any runtime entropy we can get */
 223        hash = rotate_xor(hash, &entropy, sizeof(entropy));
 224
 225#if defined(CONFIG_USE_OF)
 226        /* Get any additional entropy passed in device tree */
 227        if (initial_boot_params) {
 228                int node, len;
 229                u64 *prop;
 230
 231                node = fdt_path_offset(initial_boot_params, "/chosen");
 232                if (node >= 0) {
 233                        prop = fdt_getprop_w(initial_boot_params, node,
 234                                             "kaslr-seed", &len);
 235                        if (prop && (len == sizeof(u64)))
 236                                hash = rotate_xor(hash, prop, sizeof(*prop));
 237                }
 238        }
 239#endif /* CONFIG_USE_OF */
 240
 241        return hash;
 242}
 243
 244static inline __init bool kaslr_disabled(void)
 245{
 246        char *str;
 247
 248#if defined(CONFIG_CMDLINE_BOOL)
 249        const char *builtin_cmdline = CONFIG_CMDLINE;
 250
 251        str = strstr(builtin_cmdline, "nokaslr");
 252        if (str == builtin_cmdline ||
 253            (str > builtin_cmdline && *(str - 1) == ' '))
 254                return true;
 255#endif
 256        str = strstr(arcs_cmdline, "nokaslr");
 257        if (str == arcs_cmdline || (str > arcs_cmdline && *(str - 1) == ' '))
 258                return true;
 259
 260        return false;
 261}
 262
 263static inline void __init *determine_relocation_address(void)
 264{
 265        /* Choose a new address for the kernel */
 266        unsigned long kernel_length;
 267        void *dest = &_text;
 268        unsigned long offset;
 269
 270        if (kaslr_disabled())
 271                return dest;
 272
 273        kernel_length = (long)_end - (long)(&_text);
 274
 275        offset = get_random_boot() << 16;
 276        offset &= (CONFIG_RANDOMIZE_BASE_MAX_OFFSET - 1);
 277        if (offset < kernel_length)
 278                offset += ALIGN(kernel_length, 0xffff);
 279
 280        return RELOCATED(dest);
 281}
 282
 283#else
 284
 285static inline void __init *determine_relocation_address(void)
 286{
 287        /*
 288         * Choose a new address for the kernel
 289         * For now we'll hard code the destination
 290         */
 291        return (void *)0xffffffff81000000;
 292}
 293
 294#endif
 295
 296static inline int __init relocation_addr_valid(void *loc_new)
 297{
 298        if ((unsigned long)loc_new & 0x0000ffff) {
 299                /* Inappropriately aligned new location */
 300                return 0;
 301        }
 302        if ((unsigned long)loc_new < (unsigned long)&_end) {
 303                /* New location overlaps original kernel */
 304                return 0;
 305        }
 306        return 1;
 307}
 308
 309static inline void __init update_kaslr_offset(unsigned long *addr, long offset)
 310{
 311        unsigned long *new_addr = (unsigned long *)RELOCATED(addr);
 312
 313        *new_addr = (unsigned long)offset;
 314}
 315
 316#if defined(CONFIG_USE_OF)
 317void __weak *plat_get_fdt(void)
 318{
 319        return NULL;
 320}
 321#endif
 322
 323void *__init relocate_kernel(void)
 324{
 325        void *loc_new;
 326        unsigned long kernel_length;
 327        unsigned long bss_length;
 328        long offset = 0;
 329        int res = 1;
 330        /* Default to original kernel entry point */
 331        void *kernel_entry = start_kernel;
 332        void *fdt = NULL;
 333
 334        /* Get the command line */
 335        fw_init_cmdline();
 336#if defined(CONFIG_USE_OF)
 337        /* Deal with the device tree */
 338        fdt = plat_get_fdt();
 339        early_init_dt_scan(fdt);
 340        if (boot_command_line[0]) {
 341                /* Boot command line was passed in device tree */
 342                strlcpy(arcs_cmdline, boot_command_line, COMMAND_LINE_SIZE);
 343        }
 344#endif /* CONFIG_USE_OF */
 345
 346        kernel_length = (long)(&_relocation_start) - (long)(&_text);
 347        bss_length = (long)&__bss_stop - (long)&__bss_start;
 348
 349        loc_new = determine_relocation_address();
 350
 351        /* Sanity check relocation address */
 352        if (relocation_addr_valid(loc_new))
 353                offset = (unsigned long)loc_new - (unsigned long)(&_text);
 354
 355        /* Reset the command line now so we don't end up with a duplicate */
 356        arcs_cmdline[0] = '\0';
 357
 358        if (offset) {
 359                void (*fdt_relocated_)(void *) = NULL;
 360#if defined(CONFIG_USE_OF)
 361                unsigned long fdt_phys = virt_to_phys(fdt);
 362
 363                /*
 364                 * If built-in dtb is used then it will have been relocated
 365                 * during kernel _text relocation. If appended DTB is used
 366                 * then it will not be relocated, but it should remain
 367                 * intact in the original location. If dtb is loaded by
 368                 * the bootloader then it may need to be moved if it crosses
 369                 * the target memory area
 370                 */
 371
 372                if (fdt_phys >= virt_to_phys(RELOCATED(&_text)) &&
 373                        fdt_phys <= virt_to_phys(RELOCATED(&_end))) {
 374                        void *fdt_relocated =
 375                                RELOCATED(ALIGN((long)&_end, PAGE_SIZE));
 376                        memcpy(fdt_relocated, fdt, fdt_totalsize(fdt));
 377                        fdt = fdt_relocated;
 378                        fdt_relocated_ = RELOCATED(&plat_fdt_relocated);
 379                }
 380#endif /* CONFIG_USE_OF */
 381
 382                /* Copy the kernel to it's new location */
 383                memcpy(loc_new, &_text, kernel_length);
 384
 385                /* Perform relocations on the new kernel */
 386                res = do_relocations(&_text, loc_new, offset);
 387                if (res < 0)
 388                        goto out;
 389
 390                /* Sync the caches ready for execution of new kernel */
 391                sync_icache(loc_new, kernel_length);
 392
 393                res = relocate_exception_table(offset);
 394                if (res < 0)
 395                        goto out;
 396
 397                /*
 398                 * The original .bss has already been cleared, and
 399                 * some variables such as command line parameters
 400                 * stored to it so make a copy in the new location.
 401                 */
 402                memcpy(RELOCATED(&__bss_start), &__bss_start, bss_length);
 403
 404                /*
 405                 * If fdt was stored outside of the kernel image and
 406                 * had to be moved then update platform's state data
 407                 * with the new fdt location
 408                 */
 409                if (fdt_relocated_)
 410                        fdt_relocated_(fdt);
 411
 412                /*
 413                 * Last chance for the platform to abort relocation.
 414                 * This may also be used by the platform to perform any
 415                 * initialisation required now that the new kernel is
 416                 * resident in memory and ready to be executed.
 417                 */
 418                if (plat_post_relocation(offset))
 419                        goto out;
 420
 421                /* The current thread is now within the relocated image */
 422                __current_thread_info = RELOCATED(&init_thread_union);
 423
 424                /* Return the new kernel's entry point */
 425                kernel_entry = RELOCATED(start_kernel);
 426
 427                /* Error may occur before, so keep it at last */
 428                update_kaslr_offset(&__kaslr_offset, offset);
 429        }
 430out:
 431        return kernel_entry;
 432}
 433
 434/*
 435 * Show relocation information on panic.
 436 */
 437static void show_kernel_relocation(const char *level)
 438{
 439        if (__kaslr_offset > 0) {
 440                printk(level);
 441                pr_cont("Kernel relocated by 0x%pK\n", (void *)__kaslr_offset);
 442                pr_cont(" .text @ 0x%pK\n", _text);
 443                pr_cont(" .data @ 0x%pK\n", _sdata);
 444                pr_cont(" .bss  @ 0x%pK\n", __bss_start);
 445        }
 446}
 447
 448static int kernel_location_notifier_fn(struct notifier_block *self,
 449                                       unsigned long v, void *p)
 450{
 451        show_kernel_relocation(KERN_EMERG);
 452        return NOTIFY_DONE;
 453}
 454
 455static struct notifier_block kernel_location_notifier = {
 456        .notifier_call = kernel_location_notifier_fn
 457};
 458
 459static int __init register_kernel_offset_dumper(void)
 460{
 461        atomic_notifier_chain_register(&panic_notifier_list,
 462                                       &kernel_location_notifier);
 463        return 0;
 464}
 465__initcall(register_kernel_offset_dumper);
 466