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 28 extern u32 _relocation_start[]; /* End kernel image / start relocation table */ 29 extern u32 _relocation_end[]; /* End relocation table */ 30 31 extern long __start___ex_table; /* Start exception table */ 32 extern long __stop___ex_table; /* End exception table */ 33 34 extern 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 */ 41 int __weak plat_post_relocation(long offset) 42 { 43 return 0; 44 } 45 46 static 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 55 static 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 73 static void __init apply_r_mips_64_rel(u32 *loc_new, long offset) 74 { 75 *(u64 *)loc_new += offset; 76 } 77 78 static void __init apply_r_mips_32_rel(u32 *loc_new, long offset) 79 { 80 *loc_new += offset; 81 } 82 83 static 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 113 static 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 124 static 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 148 static 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 */ 178 static 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 193 static 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 214 static 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 244 static 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 263 static 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 285 static 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 296 static 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 309 static 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) 317 void __weak *plat_get_fdt(void) 318 { 319 return NULL; 320 } 321 #endif 322 323 void *__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 } 430 out: 431 return kernel_entry; 432 } 433 434 /* 435 * Show relocation information on panic. 436 */ 437 static 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 448 static 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 455 static struct notifier_block kernel_location_notifier = { 456 .notifier_call = kernel_location_notifier_fn 457 }; 458 459 static 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