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); 467