arch/mips/kernel/relocate.c

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