1 /*
2 * AVR32-specific kernel module loader
3 *
4 * Copyright (C) 2005-2006 Atmel Corporation
5 *
6 * GOT initialization parts are based on the s390 version
7 * Copyright (C) 2002, 2003 IBM Deutschland Entwicklung GmbH,
8 * IBM Corporation
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
13 */
14
15 #include <linux/bug.h>
16 #include <linux/elf.h>
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/moduleloader.h>
20 #include <linux/vmalloc.h>
21
module_free(struct module * mod,void * module_region)22 void module_free(struct module *mod, void *module_region)
23 {
24 vfree(mod->arch.syminfo);
25 mod->arch.syminfo = NULL;
26
27 vfree(module_region);
28 }
29
check_rela(Elf32_Rela * rela,struct module * module,char * strings,Elf32_Sym * symbols)30 static inline int check_rela(Elf32_Rela *rela, struct module *module,
31 char *strings, Elf32_Sym *symbols)
32 {
33 struct mod_arch_syminfo *info;
34
35 info = module->arch.syminfo + ELF32_R_SYM(rela->r_info);
36 switch (ELF32_R_TYPE(rela->r_info)) {
37 case R_AVR32_GOT32:
38 case R_AVR32_GOT16:
39 case R_AVR32_GOT8:
40 case R_AVR32_GOT21S:
41 case R_AVR32_GOT18SW: /* mcall */
42 case R_AVR32_GOT16S: /* ld.w */
43 if (rela->r_addend != 0) {
44 printk(KERN_ERR
45 "GOT relocation against %s at offset %u with addend\n",
46 strings + symbols[ELF32_R_SYM(rela->r_info)].st_name,
47 rela->r_offset);
48 return -ENOEXEC;
49 }
50 if (info->got_offset == -1UL) {
51 info->got_offset = module->arch.got_size;
52 module->arch.got_size += sizeof(void *);
53 }
54 pr_debug("GOT[%3lu] %s\n", info->got_offset,
55 strings + symbols[ELF32_R_SYM(rela->r_info)].st_name);
56 break;
57 }
58
59 return 0;
60 }
61
module_frob_arch_sections(Elf_Ehdr * hdr,Elf_Shdr * sechdrs,char * secstrings,struct module * module)62 int module_frob_arch_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs,
63 char *secstrings, struct module *module)
64 {
65 Elf32_Shdr *symtab;
66 Elf32_Sym *symbols;
67 Elf32_Rela *rela;
68 char *strings;
69 int nrela, i, j;
70 int ret;
71
72 /* Find the symbol table */
73 symtab = NULL;
74 for (i = 0; i < hdr->e_shnum; i++)
75 switch (sechdrs[i].sh_type) {
76 case SHT_SYMTAB:
77 symtab = &sechdrs[i];
78 break;
79 }
80 if (!symtab) {
81 printk(KERN_ERR "module %s: no symbol table\n", module->name);
82 return -ENOEXEC;
83 }
84
85 /* Allocate room for one syminfo structure per symbol. */
86 module->arch.nsyms = symtab->sh_size / sizeof(Elf_Sym);
87 module->arch.syminfo = vmalloc(module->arch.nsyms
88 * sizeof(struct mod_arch_syminfo));
89 if (!module->arch.syminfo)
90 return -ENOMEM;
91
92 symbols = (void *)hdr + symtab->sh_offset;
93 strings = (void *)hdr + sechdrs[symtab->sh_link].sh_offset;
94 for (i = 0; i < module->arch.nsyms; i++) {
95 if (symbols[i].st_shndx == SHN_UNDEF &&
96 strcmp(strings + symbols[i].st_name,
97 "_GLOBAL_OFFSET_TABLE_") == 0)
98 /* "Define" it as absolute. */
99 symbols[i].st_shndx = SHN_ABS;
100 module->arch.syminfo[i].got_offset = -1UL;
101 module->arch.syminfo[i].got_initialized = 0;
102 }
103
104 /* Allocate GOT entries for symbols that need it. */
105 module->arch.got_size = 0;
106 for (i = 0; i < hdr->e_shnum; i++) {
107 if (sechdrs[i].sh_type != SHT_RELA)
108 continue;
109 nrela = sechdrs[i].sh_size / sizeof(Elf32_Rela);
110 rela = (void *)hdr + sechdrs[i].sh_offset;
111 for (j = 0; j < nrela; j++) {
112 ret = check_rela(rela + j, module,
113 strings, symbols);
114 if (ret)
115 goto out_free_syminfo;
116 }
117 }
118
119 /*
120 * Increase core size to make room for GOT and set start
121 * offset for GOT.
122 */
123 module->core_size = ALIGN(module->core_size, 4);
124 module->arch.got_offset = module->core_size;
125 module->core_size += module->arch.got_size;
126
127 return 0;
128
129 out_free_syminfo:
130 vfree(module->arch.syminfo);
131 module->arch.syminfo = NULL;
132
133 return ret;
134 }
135
reloc_overflow(struct module * module,const char * reloc_name,Elf32_Addr relocation)136 static inline int reloc_overflow(struct module *module, const char *reloc_name,
137 Elf32_Addr relocation)
138 {
139 printk(KERN_ERR "module %s: Value %lx does not fit relocation %s\n",
140 module->name, (unsigned long)relocation, reloc_name);
141 return -ENOEXEC;
142 }
143
144 #define get_u16(loc) (*((uint16_t *)loc))
145 #define put_u16(loc, val) (*((uint16_t *)loc) = (val))
146
apply_relocate_add(Elf32_Shdr * sechdrs,const char * strtab,unsigned int symindex,unsigned int relindex,struct module * module)147 int apply_relocate_add(Elf32_Shdr *sechdrs, const char *strtab,
148 unsigned int symindex, unsigned int relindex,
149 struct module *module)
150 {
151 Elf32_Shdr *symsec = sechdrs + symindex;
152 Elf32_Shdr *relsec = sechdrs + relindex;
153 Elf32_Shdr *dstsec = sechdrs + relsec->sh_info;
154 Elf32_Rela *rel = (void *)relsec->sh_addr;
155 unsigned int i;
156 int ret = 0;
157
158 for (i = 0; i < relsec->sh_size / sizeof(Elf32_Rela); i++, rel++) {
159 struct mod_arch_syminfo *info;
160 Elf32_Sym *sym;
161 Elf32_Addr relocation;
162 uint32_t *location;
163 uint32_t value;
164
165 location = (void *)dstsec->sh_addr + rel->r_offset;
166 sym = (Elf32_Sym *)symsec->sh_addr + ELF32_R_SYM(rel->r_info);
167 relocation = sym->st_value + rel->r_addend;
168
169 info = module->arch.syminfo + ELF32_R_SYM(rel->r_info);
170
171 /* Initialize GOT entry if necessary */
172 switch (ELF32_R_TYPE(rel->r_info)) {
173 case R_AVR32_GOT32:
174 case R_AVR32_GOT16:
175 case R_AVR32_GOT8:
176 case R_AVR32_GOT21S:
177 case R_AVR32_GOT18SW:
178 case R_AVR32_GOT16S:
179 if (!info->got_initialized) {
180 Elf32_Addr *gotent;
181
182 gotent = (module->module_core
183 + module->arch.got_offset
184 + info->got_offset);
185 *gotent = relocation;
186 info->got_initialized = 1;
187 }
188
189 relocation = info->got_offset;
190 break;
191 }
192
193 switch (ELF32_R_TYPE(rel->r_info)) {
194 case R_AVR32_32:
195 case R_AVR32_32_CPENT:
196 *location = relocation;
197 break;
198 case R_AVR32_22H_PCREL:
199 relocation -= (Elf32_Addr)location;
200 if ((relocation & 0xffe00001) != 0
201 && (relocation & 0xffc00001) != 0xffc00000)
202 return reloc_overflow(module,
203 "R_AVR32_22H_PCREL",
204 relocation);
205 relocation >>= 1;
206
207 value = *location;
208 value = ((value & 0xe1ef0000)
209 | (relocation & 0xffff)
210 | ((relocation & 0x10000) << 4)
211 | ((relocation & 0x1e0000) << 8));
212 *location = value;
213 break;
214 case R_AVR32_11H_PCREL:
215 relocation -= (Elf32_Addr)location;
216 if ((relocation & 0xfffffc01) != 0
217 && (relocation & 0xfffff801) != 0xfffff800)
218 return reloc_overflow(module,
219 "R_AVR32_11H_PCREL",
220 relocation);
221 value = get_u16(location);
222 value = ((value & 0xf00c)
223 | ((relocation & 0x1fe) << 3)
224 | ((relocation & 0x600) >> 9));
225 put_u16(location, value);
226 break;
227 case R_AVR32_9H_PCREL:
228 relocation -= (Elf32_Addr)location;
229 if ((relocation & 0xffffff01) != 0
230 && (relocation & 0xfffffe01) != 0xfffffe00)
231 return reloc_overflow(module,
232 "R_AVR32_9H_PCREL",
233 relocation);
234 value = get_u16(location);
235 value = ((value & 0xf00f)
236 | ((relocation & 0x1fe) << 3));
237 put_u16(location, value);
238 break;
239 case R_AVR32_9UW_PCREL:
240 relocation -= ((Elf32_Addr)location) & 0xfffffffc;
241 if ((relocation & 0xfffffc03) != 0)
242 return reloc_overflow(module,
243 "R_AVR32_9UW_PCREL",
244 relocation);
245 value = get_u16(location);
246 value = ((value & 0xf80f)
247 | ((relocation & 0x1fc) << 2));
248 put_u16(location, value);
249 break;
250 case R_AVR32_GOTPC:
251 /*
252 * R6 = PC - (PC - GOT)
253 *
254 * At this point, relocation contains the
255 * value of PC. Just subtract the value of
256 * GOT, and we're done.
257 */
258 pr_debug("GOTPC: PC=0x%x, got_offset=0x%lx, core=0x%p\n",
259 relocation, module->arch.got_offset,
260 module->module_core);
261 relocation -= ((unsigned long)module->module_core
262 + module->arch.got_offset);
263 *location = relocation;
264 break;
265 case R_AVR32_GOT18SW:
266 if ((relocation & 0xfffe0003) != 0
267 && (relocation & 0xfffc0003) != 0xffff0000)
268 return reloc_overflow(module, "R_AVR32_GOT18SW",
269 relocation);
270 relocation >>= 2;
271 /* fall through */
272 case R_AVR32_GOT16S:
273 if ((relocation & 0xffff8000) != 0
274 && (relocation & 0xffff0000) != 0xffff0000)
275 return reloc_overflow(module, "R_AVR32_GOT16S",
276 relocation);
277 pr_debug("GOT reloc @ 0x%x -> %u\n",
278 rel->r_offset, relocation);
279 value = *location;
280 value = ((value & 0xffff0000)
281 | (relocation & 0xffff));
282 *location = value;
283 break;
284
285 default:
286 printk(KERN_ERR "module %s: Unknown relocation: %u\n",
287 module->name, ELF32_R_TYPE(rel->r_info));
288 return -ENOEXEC;
289 }
290 }
291
292 return ret;
293 }
294
module_finalize(const Elf_Ehdr * hdr,const Elf_Shdr * sechdrs,struct module * module)295 int module_finalize(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs,
296 struct module *module)
297 {
298 vfree(module->arch.syminfo);
299 module->arch.syminfo = NULL;
300
301 return 0;
302 }
303