root/arch/hexagon/kernel/module.c

DEFINITIONS

1. module_frob_arch_sections
2. apply_relocate_add

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Kernel module loader for Hexagon
   4  *
   5  * Copyright (c) 2010-2011, The Linux Foundation. All rights reserved.
   6  */
   7 
   8 #include <asm/module.h>
   9 #include <linux/elf.h>
  10 #include <linux/module.h>
  11 #include <linux/moduleloader.h>
  12 #include <linux/vmalloc.h>
  13 
  14 #if 0
  15 #define DEBUGP printk
  16 #else
  17 #define DEBUGP(fmt , ...)
  18 #endif
  19 
  20 /*
  21  * module_frob_arch_sections - tweak got/plt sections.
  22  * @hdr - pointer to elf header
  23  * @sechdrs - pointer to elf load section headers
  24  * @secstrings - symbol names
  25  * @mod - pointer to module
  26  */
  27 int module_frob_arch_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs,
  28                                 char *secstrings,
  29                                 struct module *mod)
  30 {
  31         unsigned int i;
  32         int found = 0;
  33 
  34         /* Look for .plt and/or .got.plt and/or .init.plt sections */
  35         for (i = 0; i < hdr->e_shnum; i++) {
  36                 DEBUGP("Section %d is %s\n", i,
  37                        secstrings + sechdrs[i].sh_name);
  38                 if (strcmp(secstrings + sechdrs[i].sh_name, ".plt") == 0)
  39                         found = i+1;
  40                 if (strcmp(secstrings + sechdrs[i].sh_name, ".got.plt") == 0)
  41                         found = i+1;
  42                 if (strcmp(secstrings + sechdrs[i].sh_name, ".rela.plt") == 0)
  43                         found = i+1;
  44         }
  45 
  46         /* At this time, we don't support modules comiled with -shared */
  47         if (found) {
  48                 printk(KERN_WARNING
  49                         "Module '%s' contains unexpected .plt/.got sections.\n",
  50                         mod->name);
  51                 /*  return -ENOEXEC;  */
  52         }
  53 
  54         return 0;
  55 }
  56 
  57 /*
  58  * apply_relocate_add - perform rela relocations.
  59  * @sechdrs - pointer to section headers
  60  * @strtab - some sort of start address?
  61  * @symindex - symbol index offset or something?
  62  * @relsec - address to relocate to?
  63  * @module - pointer to module
  64  *
  65  * Perform rela relocations.
  66  */
  67 int apply_relocate_add(Elf_Shdr *sechdrs, const char *strtab,
  68                         unsigned int symindex, unsigned int relsec,
  69                         struct module *module)
  70 {
  71         unsigned int i;
  72         Elf32_Sym *sym;
  73         uint32_t *location;
  74         uint32_t value;
  75         unsigned int nrelocs = sechdrs[relsec].sh_size / sizeof(Elf32_Rela);
  76         Elf32_Rela *rela = (void *)sechdrs[relsec].sh_addr;
  77         Elf32_Word sym_info = sechdrs[relsec].sh_info;
  78         Elf32_Sym *sym_base = (Elf32_Sym *) sechdrs[symindex].sh_addr;
  79         void *loc_base = (void *) sechdrs[sym_info].sh_addr;
  80 
  81         DEBUGP("Applying relocations in section %u to section %u base=%p\n",
  82                relsec, sym_info, loc_base);
  83 
  84         for (i = 0; i < nrelocs; i++) {
  85 
  86                 /* Symbol to relocate */
  87                 sym = sym_base + ELF32_R_SYM(rela[i].r_info);
  88 
  89                 /* Where to make the change */
  90                 location = loc_base + rela[i].r_offset;
  91 
  92                 /* `Everything is relative'. */
  93                 value = sym->st_value + rela[i].r_addend;
  94 
  95                 DEBUGP("%d: value=%08x loc=%p reloc=%d symbol=%s\n",
  96                        i, value, location, ELF32_R_TYPE(rela[i].r_info),
  97                        sym->st_name ?
  98                        &strtab[sym->st_name] : "(anonymous)");
  99 
 100                 switch (ELF32_R_TYPE(rela[i].r_info)) {
 101                 case R_HEXAGON_B22_PCREL: {
 102                         int dist = (int)(value - (uint32_t)location);
 103                         if ((dist < -0x00800000) ||
 104                             (dist >= 0x00800000)) {
 105                                 printk(KERN_ERR
 106                                        "%s: %s: %08x=%08x-%08x %s\n",
 107                                        module->name,
 108                                        "R_HEXAGON_B22_PCREL reloc out of range",
 109                                        dist, value, (uint32_t)location,
 110                                        sym->st_name ?
 111                                        &strtab[sym->st_name] : "(anonymous)");
 112                                 return -ENOEXEC;
 113                         }
 114                         DEBUGP("B22_PCREL contents: %08X.\n", *location);
 115                         *location &= ~0x01ff3fff;
 116                         *location |= 0x00003fff & dist;
 117                         *location |= 0x01ff0000 & (dist<<2);
 118                         DEBUGP("Contents after reloc: %08x\n", *location);
 119                         break;
 120                 }
 121                 case R_HEXAGON_HI16:
 122                         value = (value>>16) & 0xffff;
 123                         /* fallthrough */
 124                 case R_HEXAGON_LO16:
 125                         *location &= ~0x00c03fff;
 126                         *location |= value & 0x3fff;
 127                         *location |= (value & 0xc000) << 8;
 128                         break;
 129                 case R_HEXAGON_32:
 130                         *location = value;
 131                         break;
 132                 case R_HEXAGON_32_PCREL:
 133                         *location = value - (uint32_t)location;
 134                         break;
 135                 case R_HEXAGON_PLT_B22_PCREL:
 136                 case R_HEXAGON_GOTOFF_LO16:
 137                 case R_HEXAGON_GOTOFF_HI16:
 138                         printk(KERN_ERR "%s: GOT/PLT relocations unsupported\n",
 139                                module->name);
 140                         return -ENOEXEC;
 141                 default:
 142                         printk(KERN_ERR "%s: unknown relocation: %u\n",
 143                                module->name,
 144                                ELF32_R_TYPE(rela[i].r_info));
 145                         return -ENOEXEC;
 146                 }
 147         }
 148         return 0;
 149 }