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