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