| /* Kernel module help for Meta. |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2 of the License, or |
| (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| */ |
| #include <linux/moduleloader.h> |
| #include <linux/elf.h> |
| #include <linux/vmalloc.h> |
| #include <linux/fs.h> |
| #include <linux/string.h> |
| #include <linux/kernel.h> |
| #include <linux/sort.h> |
| |
| #include <asm/unaligned.h> |
| |
| /* Count how many different relocations (different symbol, different |
| addend) */ |
| static unsigned int count_relocs(const Elf32_Rela *rela, unsigned int num) |
| { |
| unsigned int i, r_info, r_addend, _count_relocs; |
| |
| _count_relocs = 0; |
| r_info = 0; |
| r_addend = 0; |
| for (i = 0; i < num; i++) |
| /* Only count relbranch relocs, others don't need stubs */ |
| if (ELF32_R_TYPE(rela[i].r_info) == R_METAG_RELBRANCH && |
| (r_info != ELF32_R_SYM(rela[i].r_info) || |
| r_addend != rela[i].r_addend)) { |
| _count_relocs++; |
| r_info = ELF32_R_SYM(rela[i].r_info); |
| r_addend = rela[i].r_addend; |
| } |
| |
| return _count_relocs; |
| } |
| |
| static int relacmp(const void *_x, const void *_y) |
| { |
| const Elf32_Rela *x, *y; |
| |
| y = (Elf32_Rela *)_x; |
| x = (Elf32_Rela *)_y; |
| |
| /* Compare the entire r_info (as opposed to ELF32_R_SYM(r_info) only) to |
| * make the comparison cheaper/faster. It won't affect the sorting or |
| * the counting algorithms' performance |
| */ |
| if (x->r_info < y->r_info) |
| return -1; |
| else if (x->r_info > y->r_info) |
| return 1; |
| else if (x->r_addend < y->r_addend) |
| return -1; |
| else if (x->r_addend > y->r_addend) |
| return 1; |
| else |
| return 0; |
| } |
| |
| static void relaswap(void *_x, void *_y, int size) |
| { |
| uint32_t *x, *y, tmp; |
| int i; |
| |
| y = (uint32_t *)_x; |
| x = (uint32_t *)_y; |
| |
| for (i = 0; i < sizeof(Elf32_Rela) / sizeof(uint32_t); i++) { |
| tmp = x[i]; |
| x[i] = y[i]; |
| y[i] = tmp; |
| } |
| } |
| |
| /* Get the potential trampolines size required of the init and |
| non-init sections */ |
| static unsigned long get_plt_size(const Elf32_Ehdr *hdr, |
| const Elf32_Shdr *sechdrs, |
| const char *secstrings, |
| int is_init) |
| { |
| unsigned long ret = 0; |
| unsigned i; |
| |
| /* Everything marked ALLOC (this includes the exported |
| symbols) */ |
| for (i = 1; i < hdr->e_shnum; i++) { |
| /* If it's called *.init*, and we're not init, we're |
| not interested */ |
| if ((strstr(secstrings + sechdrs[i].sh_name, ".init") != NULL) |
| != is_init) |
| continue; |
| |
| /* We don't want to look at debug sections. */ |
| if (strstr(secstrings + sechdrs[i].sh_name, ".debug") != NULL) |
| continue; |
| |
| if (sechdrs[i].sh_type == SHT_RELA) { |
| pr_debug("Found relocations in section %u\n", i); |
| pr_debug("Ptr: %p. Number: %u\n", |
| (void *)hdr + sechdrs[i].sh_offset, |
| sechdrs[i].sh_size / sizeof(Elf32_Rela)); |
| |
| /* Sort the relocation information based on a symbol and |
| * addend key. This is a stable O(n*log n) complexity |
| * alogrithm but it will reduce the complexity of |
| * count_relocs() to linear complexity O(n) |
| */ |
| sort((void *)hdr + sechdrs[i].sh_offset, |
| sechdrs[i].sh_size / sizeof(Elf32_Rela), |
| sizeof(Elf32_Rela), relacmp, relaswap); |
| |
| ret += count_relocs((void *)hdr |
| + sechdrs[i].sh_offset, |
| sechdrs[i].sh_size |
| / sizeof(Elf32_Rela)) |
| * sizeof(struct metag_plt_entry); |
| } |
| } |
| |
| return ret; |
| } |
| |
| int module_frob_arch_sections(Elf32_Ehdr *hdr, |
| Elf32_Shdr *sechdrs, |
| char *secstrings, |
| struct module *me) |
| { |
| unsigned int i; |
| |
| /* Find .plt and .init.plt sections */ |
| for (i = 0; i < hdr->e_shnum; i++) { |
| if (strcmp(secstrings + sechdrs[i].sh_name, ".init.plt") == 0) |
| me->arch.init_plt_section = i; |
| else if (strcmp(secstrings + sechdrs[i].sh_name, ".plt") == 0) |
| me->arch.core_plt_section = i; |
| } |
| if (!me->arch.core_plt_section || !me->arch.init_plt_section) { |
| pr_err("Module doesn't contain .plt or .init.plt sections.\n"); |
| return -ENOEXEC; |
| } |
| |
| /* Override their sizes */ |
| sechdrs[me->arch.core_plt_section].sh_size |
| = get_plt_size(hdr, sechdrs, secstrings, 0); |
| sechdrs[me->arch.core_plt_section].sh_type = SHT_NOBITS; |
| sechdrs[me->arch.init_plt_section].sh_size |
| = get_plt_size(hdr, sechdrs, secstrings, 1); |
| sechdrs[me->arch.init_plt_section].sh_type = SHT_NOBITS; |
| return 0; |
| } |
| |
| /* Set up a trampoline in the PLT to bounce us to the distant function */ |
| static uint32_t do_plt_call(void *location, Elf32_Addr val, |
| Elf32_Shdr *sechdrs, struct module *mod) |
| { |
| struct metag_plt_entry *entry; |
| /* Instructions used to do the indirect jump. */ |
| uint32_t tramp[2]; |
| |
| /* We have to trash a register, so we assume that any control |
| transfer more than 21-bits away must be a function call |
| (so we can use a call-clobbered register). */ |
| |
| /* MOVT D0Re0,#HI(v) */ |
| tramp[0] = 0x02000005 | (((val & 0xffff0000) >> 16) << 3); |
| /* JUMP D0Re0,#LO(v) */ |
| tramp[1] = 0xac000001 | ((val & 0x0000ffff) << 3); |
| |
| /* Init, or core PLT? */ |
| if (location >= mod->module_core |
| && location < mod->module_core + mod->core_size) |
| entry = (void *)sechdrs[mod->arch.core_plt_section].sh_addr; |
| else |
| entry = (void *)sechdrs[mod->arch.init_plt_section].sh_addr; |
| |
| /* Find this entry, or if that fails, the next avail. entry */ |
| while (entry->tramp[0]) |
| if (entry->tramp[0] == tramp[0] && entry->tramp[1] == tramp[1]) |
| return (uint32_t)entry; |
| else |
| entry++; |
| |
| entry->tramp[0] = tramp[0]; |
| entry->tramp[1] = tramp[1]; |
| |
| return (uint32_t)entry; |
| } |
| |
| int apply_relocate_add(Elf32_Shdr *sechdrs, |
| const char *strtab, |
| unsigned int symindex, |
| unsigned int relsec, |
| struct module *me) |
| { |
| unsigned int i; |
| Elf32_Rela *rel = (void *)sechdrs[relsec].sh_addr; |
| Elf32_Sym *sym; |
| Elf32_Addr relocation; |
| uint32_t *location; |
| int32_t value; |
| |
| pr_debug("Applying relocate section %u to %u\n", relsec, |
| sechdrs[relsec].sh_info); |
| for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) { |
| /* This is where to make the change */ |
| location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr |
| + rel[i].r_offset; |
| /* This is the symbol it is referring to. Note that all |
| undefined symbols have been resolved. */ |
| sym = (Elf32_Sym *)sechdrs[symindex].sh_addr |
| + ELF32_R_SYM(rel[i].r_info); |
| relocation = sym->st_value + rel[i].r_addend; |
| |
| switch (ELF32_R_TYPE(rel[i].r_info)) { |
| case R_METAG_NONE: |
| break; |
| case R_METAG_HIADDR16: |
| relocation >>= 16; |
| case R_METAG_LOADDR16: |
| *location = (*location & 0xfff80007) | |
| ((relocation & 0xffff) << 3); |
| break; |
| case R_METAG_ADDR32: |
| /* |
| * Packed data structures may cause a misaligned |
| * R_METAG_ADDR32 to be emitted. |
| */ |
| put_unaligned(relocation, location); |
| break; |
| case R_METAG_GETSETOFF: |
| *location += ((relocation & 0xfff) << 7); |
| break; |
| case R_METAG_RELBRANCH: |
| if (*location & (0x7ffff << 5)) { |
| pr_err("bad relbranch relocation\n"); |
| break; |
| } |
| |
| /* This jump is too big for the offset slot. Build |
| * a PLT to jump through to get to where we want to go. |
| * NB: 21bit check - not scaled to 19bit yet |
| */ |
| if (((int32_t)(relocation - |
| (uint32_t)location) > 0xfffff) || |
| ((int32_t)(relocation - |
| (uint32_t)location) < -0xfffff)) { |
| relocation = do_plt_call(location, relocation, |
| sechdrs, me); |
| } |
| |
| value = relocation - (uint32_t)location; |
| |
| /* branch instruction aligned */ |
| value /= 4; |
| |
| if ((value > 0x7ffff) || (value < -0x7ffff)) { |
| /* |
| * this should have been caught by the code |
| * above! |
| */ |
| pr_err("overflow of relbranch reloc\n"); |
| } |
| |
| *location = (*location & (~(0x7ffff << 5))) | |
| ((value & 0x7ffff) << 5); |
| break; |
| |
| default: |
| pr_err("module %s: Unknown relocation: %u\n", |
| me->name, ELF32_R_TYPE(rel[i].r_info)); |
| return -ENOEXEC; |
| } |
| } |
| return 0; |
| } |