1 // SPDX-License-Identifier: GPL-2.0-or-later !! 1 /* Kernel module help for Alpha. 2 /* !! 2 Copyright (C) 2002 Richard Henderson. 3 * OpenRISC module.c << 4 * << 5 * Linux architectural port borrowing liberall << 6 * others. All original copyrights apply as p << 7 * declaration. << 8 * << 9 * Modifications for the OpenRISC architecture << 10 * Copyright (C) 2010-2011 Jonas Bonn <jonas@s << 11 */ << 12 3 >> 4 This program is free software; you can redistribute it and/or modify >> 5 it under the terms of the GNU General Public License as published by >> 6 the Free Software Foundation; either version 2 of the License, or >> 7 (at your option) any later version. >> 8 >> 9 This program is distributed in the hope that it will be useful, >> 10 but WITHOUT ANY WARRANTY; without even the implied warranty of >> 11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >> 12 GNU General Public License for more details. >> 13 >> 14 You should have received a copy of the GNU General Public License >> 15 along with this program; if not, write to the Free Software >> 16 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA >> 17 */ 13 #include <linux/moduleloader.h> 18 #include <linux/moduleloader.h> 14 #include <linux/elf.h> 19 #include <linux/elf.h> >> 20 #include <linux/vmalloc.h> >> 21 #include <linux/fs.h> >> 22 #include <linux/string.h> >> 23 #include <linux/kernel.h> >> 24 #include <linux/slab.h> >> 25 >> 26 #if 0 >> 27 #define DEBUGP printk >> 28 #else >> 29 #define DEBUGP(fmt...) >> 30 #endif >> 31 >> 32 void * >> 33 module_alloc(unsigned long size) >> 34 { >> 35 if (size == 0) >> 36 return NULL; >> 37 return vmalloc(size); >> 38 } >> 39 >> 40 void >> 41 module_free(struct module *mod, void *module_region) >> 42 { >> 43 vfree(module_region); >> 44 } >> 45 >> 46 /* Allocate the GOT at the end of the core sections. */ >> 47 >> 48 struct got_entry { >> 49 struct got_entry *next; >> 50 Elf64_Addr r_offset; >> 51 int got_offset; >> 52 }; >> 53 >> 54 static inline void >> 55 process_reloc_for_got(Elf64_Rela *rela, >> 56 struct got_entry *chains, Elf64_Xword *poffset) >> 57 { >> 58 unsigned long r_sym = ELF64_R_SYM (rela->r_info); >> 59 unsigned long r_type = ELF64_R_TYPE (rela->r_info); >> 60 Elf64_Addr r_offset = rela->r_offset; >> 61 struct got_entry *g; >> 62 >> 63 if (r_type != R_ALPHA_LITERAL) >> 64 return; >> 65 >> 66 for (g = chains + r_sym; g ; g = g->next) >> 67 if (g->r_offset == r_offset) { >> 68 if (g->got_offset == 0) { >> 69 g->got_offset = *poffset; >> 70 *poffset += 8; >> 71 } >> 72 goto found_entry; >> 73 } >> 74 >> 75 g = kmalloc (sizeof (*g), GFP_KERNEL); >> 76 g->next = chains[r_sym].next; >> 77 g->r_offset = r_offset; >> 78 g->got_offset = *poffset; >> 79 *poffset += 8; >> 80 chains[r_sym].next = g; >> 81 >> 82 found_entry: >> 83 /* Trick: most of the ELF64_R_TYPE field is unused. There are >> 84 42 valid relocation types, and a 32-bit field. Co-opt the >> 85 bits above 256 to store the got offset for this reloc. */ >> 86 rela->r_info |= g->got_offset << 8; >> 87 } >> 88 >> 89 int >> 90 module_frob_arch_sections(Elf64_Ehdr *hdr, Elf64_Shdr *sechdrs, >> 91 char *secstrings, struct module *me) >> 92 { >> 93 struct got_entry *chains; >> 94 Elf64_Rela *rela; >> 95 Elf64_Shdr *esechdrs, *symtab, *s, *got; >> 96 unsigned long nsyms, nrela, i; >> 97 >> 98 esechdrs = sechdrs + hdr->e_shnum; >> 99 symtab = got = NULL; >> 100 >> 101 /* Find out how large the symbol table is. Allocate one got_entry >> 102 head per symbol. Normally this will be enough, but not always. >> 103 We'll chain different offsets for the symbol down each head. */ >> 104 for (s = sechdrs; s < esechdrs; ++s) >> 105 if (s->sh_type == SHT_SYMTAB) >> 106 symtab = s; >> 107 else if (!strcmp(".got", secstrings + s->sh_name)) { >> 108 got = s; >> 109 me->arch.gotsecindex = s - sechdrs; >> 110 } >> 111 >> 112 if (!symtab) { >> 113 printk(KERN_ERR "module %s: no symbol table\n", me->name); >> 114 return -ENOEXEC; >> 115 } >> 116 if (!got) { >> 117 printk(KERN_ERR "module %s: no got section\n", me->name); >> 118 return -ENOEXEC; >> 119 } >> 120 >> 121 nsyms = symtab->sh_size / sizeof(Elf64_Sym); >> 122 chains = kmalloc(nsyms * sizeof(struct got_entry), GFP_KERNEL); >> 123 memset(chains, 0, nsyms * sizeof(struct got_entry)); >> 124 >> 125 got->sh_size = 0; >> 126 got->sh_addralign = 8; >> 127 got->sh_type = SHT_NOBITS; >> 128 >> 129 /* Examine all LITERAL relocations to find out what GOT entries >> 130 are required. This sizes the GOT section as well. */ >> 131 for (s = sechdrs; s < esechdrs; ++s) >> 132 if (s->sh_type == SHT_RELA) { >> 133 nrela = s->sh_size / sizeof(Elf64_Rela); >> 134 rela = (void *)hdr + s->sh_offset; >> 135 for (i = 0; i < nrela; ++i) >> 136 process_reloc_for_got(rela+i, chains, >> 137 &got->sh_size); >> 138 } >> 139 >> 140 /* Free the memory we allocated. */ >> 141 for (i = 0; i < nsyms; ++i) { >> 142 struct got_entry *g, *n; >> 143 for (g = chains[i].next; g ; g = n) { >> 144 n = g->next; >> 145 kfree(g); >> 146 } >> 147 } >> 148 kfree(chains); >> 149 >> 150 return 0; >> 151 } >> 152 >> 153 int >> 154 apply_relocate(Elf64_Shdr *sechdrs, const char *strtab, unsigned int symindex, >> 155 unsigned int relsec, struct module *me) >> 156 { >> 157 printk(KERN_ERR "module %s: REL relocation unsupported\n", me->name); >> 158 return -ENOEXEC; >> 159 } >> 160 >> 161 int >> 162 apply_relocate_add(Elf64_Shdr *sechdrs, const char *strtab, >> 163 unsigned int symindex, unsigned int relsec, >> 164 struct module *me) >> 165 { >> 166 Elf64_Rela *rela = (void *)sechdrs[relsec].sh_addr; >> 167 unsigned long i, n = sechdrs[relsec].sh_size / sizeof(*rela); >> 168 Elf64_Sym *symtab, *sym; >> 169 void *base, *location; >> 170 unsigned long got, gp; >> 171 >> 172 DEBUGP("Applying relocate section %u to %u\n", relsec, >> 173 sechdrs[relsec].sh_info); 15 174 16 int apply_relocate_add(Elf32_Shdr *sechdrs, !! 175 base = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr; 17 const char *strtab, !! 176 symtab = (Elf64_Sym *)sechdrs[symindex].sh_addr; 18 unsigned int symindex, !! 177 19 unsigned int relsec, !! 178 /* The small sections were sorted to the end of the segment. 20 struct module *me) !! 179 The following should definitely cover them. */ 21 { !! 180 gp = (u64)me->module_core + me->core_size - 0x8000; 22 unsigned int i; !! 181 got = sechdrs[me->arch.gotsecindex].sh_addr; 23 Elf32_Rela *rel = (void *)sechdrs[rels !! 182 24 Elf32_Sym *sym; !! 183 for (i = 0; i < n; i++) { 25 uint32_t *location; !! 184 unsigned long r_sym = ELF64_R_SYM (rela[i].r_info); 26 uint32_t value; !! 185 unsigned long r_type = ELF64_R_TYPE (rela[i].r_info); 27 !! 186 unsigned long r_got_offset = r_type >> 8; 28 pr_debug("Applying relocate section %u !! 187 unsigned long value, hi, lo; 29 sechdrs[relsec].sh_info); !! 188 r_type &= 0xff; 30 for (i = 0; i < sechdrs[relsec].sh_siz !! 189 31 /* This is where to make the c !! 190 /* This is where to make the change. */ 32 location = (void *)sechdrs[sec !! 191 location = base + rela[i].r_offset; 33 + rel[i].r_offset; << 34 192 35 /* This is the symbol it is re 193 /* This is the symbol it is referring to. Note that all 36 undefined symbols have been !! 194 unresolved symbols have been resolved. */ 37 sym = (Elf32_Sym *)sechdrs[sym !! 195 sym = symtab + r_sym; 38 + ELF32_R_SYM(rel[i].r !! 196 value = sym->st_value + rela[i].r_addend; 39 value = sym->st_value + rel[i] !! 197 40 !! 198 switch (r_type) { 41 switch (ELF32_R_TYPE(rel[i].r_ !! 199 case R_ALPHA_NONE: 42 case R_OR1K_32: << 43 *location = value; << 44 break; << 45 case R_OR1K_LO_16_IN_INSN: << 46 *((uint16_t *)location << 47 break; << 48 case R_OR1K_HI_16_IN_INSN: << 49 *((uint16_t *)location << 50 break; << 51 case R_OR1K_INSN_REL_26: << 52 value -= (uint32_t)loc << 53 value >>= 2; << 54 value &= 0x03ffffff; << 55 value |= *location & 0 << 56 *location = value; << 57 break; << 58 case R_OR1K_AHI16: << 59 /* Adjust the operand << 60 value += 0x8000; << 61 *((uint16_t *)location << 62 break; << 63 case R_OR1K_SLO16: << 64 /* Split value lower 1 << 65 value = ((value & 0xf8 << 66 *location = (*location << 67 break; 200 break; 68 default: !! 201 case R_ALPHA_REFQUAD: 69 pr_err("module %s: Unk !! 202 /* BUG() can produce misaligned relocations. */ 70 me->name, ELF32 !! 203 ((u32 *)location)[0] = value; >> 204 ((u32 *)location)[1] = value >> 32; >> 205 break; >> 206 case R_ALPHA_GPREL32: >> 207 value -= gp; >> 208 if ((int)value != value) >> 209 goto reloc_overflow; >> 210 *(u32 *)location = value; >> 211 break; >> 212 case R_ALPHA_LITERAL: >> 213 hi = got + r_got_offset; >> 214 lo = hi - gp; >> 215 if ((short)lo != lo) >> 216 goto reloc_overflow; >> 217 *(u16 *)location = lo; >> 218 *(u64 *)hi = value; 71 break; 219 break; >> 220 case R_ALPHA_LITUSE: >> 221 break; >> 222 case R_ALPHA_GPDISP: >> 223 value = gp - (u64)location; >> 224 lo = (short)value; >> 225 hi = (int)(value - lo); >> 226 if (hi + lo != value) >> 227 goto reloc_overflow; >> 228 *(u16 *)location = hi >> 16; >> 229 *(u16 *)(location + rela[i].r_addend) = lo; >> 230 break; >> 231 case R_ALPHA_BRSGP: >> 232 /* BRSGP is only allowed to bind to local symbols. >> 233 If the section is undef, this means that the >> 234 value was resolved from somewhere else. */ >> 235 if (sym->st_shndx == SHN_UNDEF) >> 236 goto reloc_overflow; >> 237 /* FALLTHRU */ >> 238 case R_ALPHA_BRADDR: >> 239 value -= (u64)location + 4; >> 240 if (value & 3) >> 241 goto reloc_overflow; >> 242 value = (long)value >> 2; >> 243 if (value + (1<<21) >= 1<<22) >> 244 goto reloc_overflow; >> 245 value &= 0x1fffff; >> 246 value |= *(u32 *)location & ~0x1fffff; >> 247 *(u32 *)location = value; >> 248 break; >> 249 case R_ALPHA_HINT: >> 250 break; >> 251 case R_ALPHA_SREL32: >> 252 value -= (u64)location; >> 253 if ((int)value != value) >> 254 goto reloc_overflow; >> 255 *(u32 *)location = value; >> 256 break; >> 257 case R_ALPHA_SREL64: >> 258 value -= (u64)location; >> 259 *(u64 *)location = value; >> 260 break; >> 261 case R_ALPHA_GPRELHIGH: >> 262 value = (value - gp + 0x8000) >> 16; >> 263 if ((short) value != value) >> 264 goto reloc_overflow; >> 265 *(u16 *)location = value; >> 266 break; >> 267 case R_ALPHA_GPRELLOW: >> 268 value -= gp; >> 269 *(u16 *)location = value; >> 270 break; >> 271 case R_ALPHA_GPREL16: >> 272 value -= gp; >> 273 if ((short) value != value) >> 274 goto reloc_overflow; >> 275 *(u16 *)location = value; >> 276 break; >> 277 default: >> 278 printk(KERN_ERR "module %s: Unknown relocation: %lu\n", >> 279 me->name, r_type); >> 280 return -ENOEXEC; >> 281 reloc_overflow: >> 282 if (ELF64_ST_TYPE (sym->st_info) == STT_SECTION) >> 283 printk(KERN_ERR >> 284 "module %s: Relocation overflow vs section %d\n", >> 285 me->name, sym->st_shndx); >> 286 else >> 287 printk(KERN_ERR >> 288 "module %s: Relocation overflow vs %s\n", >> 289 me->name, strtab + sym->st_name); >> 290 return -ENOEXEC; 72 } 291 } 73 } 292 } 74 293 75 return 0; 294 return 0; >> 295 } >> 296 >> 297 int >> 298 module_finalize(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs, >> 299 struct module *me) >> 300 { >> 301 return 0; >> 302 } >> 303 >> 304 void >> 305 module_arch_cleanup(struct module *mod) >> 306 { 76 } 307 } 77 308
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.