~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/mips/kernel/relocate.c

Version: ~ [ linux-5.1-rc5 ] ~ [ linux-5.0.7 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.34 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.111 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.168 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.178 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.138 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.65 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 (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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp