arch/loongarch/kernel/relocate.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Support for Kernel relocation at boot time
   4  *
   5  * Copyright (C) 2023 Loongson Technology Corporation Limited
   6  */
   7
   8 #include <linux/elf.h>
   9 #include <linux/kernel.h>
  10 #include <linux/printk.h>
  11 #include <linux/panic_notifier.h>
  12 #include <linux/start_kernel.h>
  13 #include <asm/bootinfo.h>
  14 #include <asm/early_ioremap.h>
  15 #include <asm/inst.h>
  16 #include <asm/sections.h>
  17 #include <asm/setup.h>
  18
  19 #define RELOCATED(x) ((void *)((long)x + reloc_offset))
  20 #define RELOCATED_KASLR(x) ((void *)((long)x + random_offset))
  21
  22 static unsigned long reloc_offset;
  23
  24 static inline void __init relocate_relative(void)
  25 {
  26         Elf64_Rela *rela, *rela_end;
  27         rela = (Elf64_Rela *)&__rela_dyn_begin;
  28         rela_end = (Elf64_Rela *)&__rela_dyn_end;
  29
  30         for ( ; rela < rela_end; rela++) {
  31                 Elf64_Addr addr = rela->r_offset;
  32                 Elf64_Addr relocated_addr = rela->r_addend;
  33
  34                 if (rela->r_info != R_LARCH_RELATIVE)
  35                         continue;
  36
  37                 if (relocated_addr >= VMLINUX_LOAD_ADDRESS)
  38                         relocated_addr = (Elf64_Addr)RELOCATED(relocated_addr);
  39
  40                 *(Elf64_Addr *)RELOCATED(addr) = relocated_addr;
  41         }
  42 }
  43
  44 static inline void __init relocate_absolute(long random_offset)
  45 {
  46         void *begin, *end;
  47         struct rela_la_abs *p;
  48
  49         begin = RELOCATED_KASLR(&__la_abs_begin);
  50         end   = RELOCATED_KASLR(&__la_abs_end);
  51
  52         for (p = begin; (void *)p < end; p++) {
  53                 long v = p->symvalue;
  54                 uint32_t lu12iw, ori, lu32id, lu52id;
  55                 union loongarch_instruction *insn = (void *)p - p->offset;
  56
  57                 lu12iw = (v >> 12) & 0xfffff;
  58                 ori    = v & 0xfff;
  59                 lu32id = (v >> 32) & 0xfffff;
  60                 lu52id = v >> 52;
  61
  62                 insn[0].reg1i20_format.immediate = lu12iw;
  63                 insn[1].reg2i12_format.immediate = ori;
  64                 insn[2].reg1i20_format.immediate = lu32id;
  65                 insn[3].reg2i12_format.immediate = lu52id;
  66         }
  67 }
  68
  69 #ifdef CONFIG_RANDOMIZE_BASE
  70 static inline __init unsigned long rotate_xor(unsigned long hash,
  71                                               const void *area, size_t size)
  72 {
  73         size_t i, diff;
  74         const typeof(hash) *ptr = PTR_ALIGN(area, sizeof(hash));
  75
  76         diff = (void *)ptr - area;
  77         if (size < diff + sizeof(hash))
  78                 return hash;
  79
  80         size = ALIGN_DOWN(size - diff, sizeof(hash));
  81
  82         for (i = 0; i < size / sizeof(hash); i++) {
  83                 /* Rotate by odd number of bits and XOR. */
  84                 hash = (hash << ((sizeof(hash) * 8) - 7)) | (hash >> 7);
  85                 hash ^= ptr[i];
  86         }
  87
  88         return hash;
  89 }
  90
  91 static inline __init unsigned long get_random_boot(void)
  92 {
  93         unsigned long hash = 0;
  94         unsigned long entropy = random_get_entropy();
  95
  96         /* Attempt to create a simple but unpredictable starting entropy. */
  97         hash = rotate_xor(hash, linux_banner, strlen(linux_banner));
  98
  99         /* Add in any runtime entropy we can get */
 100         hash = rotate_xor(hash, &entropy, sizeof(entropy));
 101
 102         return hash;
 103 }
 104
 105 static inline __init bool kaslr_disabled(void)
 106 {
 107         char *str;
 108         const char *builtin_cmdline = CONFIG_CMDLINE;
 109
 110         str = strstr(builtin_cmdline, "nokaslr");
 111         if (str == builtin_cmdline || (str > builtin_cmdline && *(str - 1) == ' '))
 112                 return true;
 113
 114         str = strstr(boot_command_line, "nokaslr");
 115         if (str == boot_command_line || (str > boot_command_line && *(str - 1) == ' '))
 116                 return true;
 117
 118         return false;
 119 }
 120
 121 /* Choose a new address for the kernel */
 122 static inline void __init *determine_relocation_address(void)
 123 {
 124         unsigned long kernel_length;
 125         unsigned long random_offset;
 126         void *destination = _text;
 127
 128         if (kaslr_disabled())
 129                 return destination;
 130
 131         kernel_length = (long)_end - (long)_text;
 132
 133         random_offset = get_random_boot() << 16;
 134         random_offset &= (CONFIG_RANDOMIZE_BASE_MAX_OFFSET - 1);
 135         if (random_offset < kernel_length)
 136                 random_offset += ALIGN(kernel_length, 0xffff);
 137
 138         return RELOCATED_KASLR(destination);
 139 }
 140
 141 static inline int __init relocation_addr_valid(void *location_new)
 142 {
 143         if ((unsigned long)location_new & 0x00000ffff)
 144                 return 0; /* Inappropriately aligned new location */
 145
 146         if ((unsigned long)location_new < (unsigned long)_end)
 147                 return 0; /* New location overlaps original kernel */
 148
 149         return 1;
 150 }
 151 #endif
 152
 153 static inline void __init update_reloc_offset(unsigned long *addr, long random_offset)
 154 {
 155         unsigned long *new_addr = (unsigned long *)RELOCATED_KASLR(addr);
 156
 157         *new_addr = (unsigned long)reloc_offset;
 158 }
 159
 160 unsigned long __init relocate_kernel(void)
 161 {
 162         unsigned long kernel_length;
 163         unsigned long random_offset = 0;
 164         void *location_new = _text; /* Default to original kernel start */
 165         char *cmdline = early_ioremap(fw_arg1, COMMAND_LINE_SIZE); /* Boot command line is passed in fw_arg1 */
 166
 167         strscpy(boot_command_line, cmdline, COMMAND_LINE_SIZE);
 168
 169 #ifdef CONFIG_RANDOMIZE_BASE
 170         location_new = determine_relocation_address();
 171
 172         /* Sanity check relocation address */
 173         if (relocation_addr_valid(location_new))
 174                 random_offset = (unsigned long)location_new - (unsigned long)(_text);
 175 #endif
 176         reloc_offset = (unsigned long)_text - VMLINUX_LOAD_ADDRESS;
 177
 178         if (random_offset) {
 179                 kernel_length = (long)(_end) - (long)(_text);
 180
 181                 /* Copy the kernel to it's new location */
 182                 memcpy(location_new, _text, kernel_length);
 183
 184                 /* Sync the caches ready for execution of new kernel */
 185                 __asm__ __volatile__ (
 186                         "ibar 0 \t\n"
 187                         "dbar 0 \t\n"
 188                         ::: "memory");
 189
 190                 reloc_offset += random_offset;
 191
 192                 /* The current thread is now within the relocated kernel */
 193                 __current_thread_info = RELOCATED_KASLR(__current_thread_info);
 194
 195                 update_reloc_offset(&reloc_offset, random_offset);
 196         }
 197
 198         if (reloc_offset)
 199                 relocate_relative();
 200
 201         relocate_absolute(random_offset);
 202
 203         return random_offset;
 204 }
 205
 206 /*
 207  * Show relocation information on panic.
 208  */
 209 static void show_kernel_relocation(const char *level)
 210 {
 211         if (reloc_offset > 0) {
 212                 printk(level);
 213                 pr_cont("Kernel relocated by 0x%lx\n", reloc_offset);
 214                 pr_cont(" .text @ 0x%px\n", _text);
 215                 pr_cont(" .data @ 0x%px\n", _sdata);
 216                 pr_cont(" .bss  @ 0x%px\n", __bss_start);
 217         }
 218 }
 219
 220 static int kernel_location_notifier_fn(struct notifier_block *self,
 221                                        unsigned long v, void *p)
 222 {
 223         show_kernel_relocation(KERN_EMERG);
 224         return NOTIFY_DONE;
 225 }
 226
 227 static struct notifier_block kernel_location_notifier = {
 228         .notifier_call = kernel_location_notifier_fn
 229 };
 230
 231 static int __init register_kernel_offset_dumper(void)
 232 {
 233         atomic_notifier_chain_register(&panic_notifier_list,
 234                                        &kernel_location_notifier);
 235         return 0;
 236 }
 237
 238 arch_initcall(register_kernel_offset_dumper);