Merge branches 'release' and 'autoload' into release
[linux-2.6] / arch / powerpc / kernel / module_64.c
1 /*  Kernel module help for PPC64.
2     Copyright (C) 2001, 2003 Rusty Russell IBM Corporation.
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 */
18 #include <linux/module.h>
19 #include <linux/elf.h>
20 #include <linux/moduleloader.h>
21 #include <linux/err.h>
22 #include <linux/vmalloc.h>
23 #include <linux/bug.h>
24 #include <asm/module.h>
25 #include <asm/uaccess.h>
26 #include <asm/firmware.h>
27 #include <linux/sort.h>
28
29 #include "setup.h"
30
31 /* FIXME: We don't do .init separately.  To do this, we'd need to have
32    a separate r2 value in the init and core section, and stub between
33    them, too.
34
35    Using a magic allocator which places modules within 32MB solves
36    this, and makes other things simpler.  Anton?
37    --RR.  */
38 #if 0
39 #define DEBUGP printk
40 #else
41 #define DEBUGP(fmt , ...)
42 #endif
43
44 /* There's actually a third entry here, but it's unused */
45 struct ppc64_opd_entry
46 {
47         unsigned long funcaddr;
48         unsigned long r2;
49 };
50
51 /* Like PPC32, we need little trampolines to do > 24-bit jumps (into
52    the kernel itself).  But on PPC64, these need to be used for every
53    jump, actually, to reset r2 (TOC+0x8000). */
54 struct ppc64_stub_entry
55 {
56         /* 28 byte jump instruction sequence (7 instructions) */
57         unsigned char jump[28];
58         unsigned char unused[4];
59         /* Data for the above code */
60         struct ppc64_opd_entry opd;
61 };
62
63 /* We use a stub to fix up r2 (TOC ptr) and to jump to the (external)
64    function which may be more than 24-bits away.  We could simply
65    patch the new r2 value and function pointer into the stub, but it's
66    significantly shorter to put these values at the end of the stub
67    code, and patch the stub address (32-bits relative to the TOC ptr,
68    r2) into the stub. */
69 static struct ppc64_stub_entry ppc64_stub =
70 { .jump = {
71         0x3d, 0x82, 0x00, 0x00, /* addis   r12,r2, <high> */
72         0x39, 0x8c, 0x00, 0x00, /* addi    r12,r12, <low> */
73         /* Save current r2 value in magic place on the stack. */
74         0xf8, 0x41, 0x00, 0x28, /* std     r2,40(r1) */
75         0xe9, 0x6c, 0x00, 0x20, /* ld      r11,32(r12) */
76         0xe8, 0x4c, 0x00, 0x28, /* ld      r2,40(r12) */
77         0x7d, 0x69, 0x03, 0xa6, /* mtctr   r11 */
78         0x4e, 0x80, 0x04, 0x20  /* bctr */
79 } };
80
81 /* Count how many different 24-bit relocations (different symbol,
82    different addend) */
83 static unsigned int count_relocs(const Elf64_Rela *rela, unsigned int num)
84 {
85         unsigned int i, r_info, r_addend, _count_relocs;
86
87         /* FIXME: Only count external ones --RR */
88         _count_relocs = 0;
89         r_info = 0;
90         r_addend = 0;
91         for (i = 0; i < num; i++)
92                 /* Only count 24-bit relocs, others don't need stubs */
93                 if (ELF64_R_TYPE(rela[i].r_info) == R_PPC_REL24 &&
94                     (r_info != ELF64_R_SYM(rela[i].r_info) ||
95                      r_addend != rela[i].r_addend)) {
96                         _count_relocs++;
97                         r_info = ELF64_R_SYM(rela[i].r_info);
98                         r_addend = rela[i].r_addend;
99                 }
100
101         return _count_relocs;
102 }
103
104 void *module_alloc(unsigned long size)
105 {
106         if (size == 0)
107                 return NULL;
108
109         return vmalloc_exec(size);
110 }
111
112 /* Free memory returned from module_alloc */
113 void module_free(struct module *mod, void *module_region)
114 {
115         vfree(module_region);
116         /* FIXME: If module_region == mod->init_region, trim exception
117            table entries. */
118 }
119
120 static int relacmp(const void *_x, const void *_y)
121 {
122         const Elf64_Rela *x, *y;
123
124         y = (Elf64_Rela *)_x;
125         x = (Elf64_Rela *)_y;
126
127         /* Compare the entire r_info (as opposed to ELF64_R_SYM(r_info) only) to
128          * make the comparison cheaper/faster. It won't affect the sorting or
129          * the counting algorithms' performance
130          */
131         if (x->r_info < y->r_info)
132                 return -1;
133         else if (x->r_info > y->r_info)
134                 return 1;
135         else if (x->r_addend < y->r_addend)
136                 return -1;
137         else if (x->r_addend > y->r_addend)
138                 return 1;
139         else
140                 return 0;
141 }
142
143 static void relaswap(void *_x, void *_y, int size)
144 {
145         uint64_t *x, *y, tmp;
146         int i;
147
148         y = (uint64_t *)_x;
149         x = (uint64_t *)_y;
150
151         for (i = 0; i < sizeof(Elf64_Rela) / sizeof(uint64_t); i++) {
152                 tmp = x[i];
153                 x[i] = y[i];
154                 y[i] = tmp;
155         }
156 }
157
158 /* Get size of potential trampolines required. */
159 static unsigned long get_stubs_size(const Elf64_Ehdr *hdr,
160                                     const Elf64_Shdr *sechdrs)
161 {
162         /* One extra reloc so it's always 0-funcaddr terminated */
163         unsigned long relocs = 1;
164         unsigned i;
165
166         /* Every relocated section... */
167         for (i = 1; i < hdr->e_shnum; i++) {
168                 if (sechdrs[i].sh_type == SHT_RELA) {
169                         DEBUGP("Found relocations in section %u\n", i);
170                         DEBUGP("Ptr: %p.  Number: %lu\n",
171                                (void *)sechdrs[i].sh_addr,
172                                sechdrs[i].sh_size / sizeof(Elf64_Rela));
173
174                         /* Sort the relocation information based on a symbol and
175                          * addend key. This is a stable O(n*log n) complexity
176                          * alogrithm but it will reduce the complexity of
177                          * count_relocs() to linear complexity O(n)
178                          */
179                         sort((void *)sechdrs[i].sh_addr,
180                              sechdrs[i].sh_size / sizeof(Elf64_Rela),
181                              sizeof(Elf64_Rela), relacmp, relaswap);
182
183                         relocs += count_relocs((void *)sechdrs[i].sh_addr,
184                                                sechdrs[i].sh_size
185                                                / sizeof(Elf64_Rela));
186                 }
187         }
188
189         DEBUGP("Looks like a total of %lu stubs, max\n", relocs);
190         return relocs * sizeof(struct ppc64_stub_entry);
191 }
192
193 static void dedotify_versions(struct modversion_info *vers,
194                               unsigned long size)
195 {
196         struct modversion_info *end;
197
198         for (end = (void *)vers + size; vers < end; vers++)
199                 if (vers->name[0] == '.')
200                         memmove(vers->name, vers->name+1, strlen(vers->name));
201 }
202
203 /* Undefined symbols which refer to .funcname, hack to funcname */
204 static void dedotify(Elf64_Sym *syms, unsigned int numsyms, char *strtab)
205 {
206         unsigned int i;
207
208         for (i = 1; i < numsyms; i++) {
209                 if (syms[i].st_shndx == SHN_UNDEF) {
210                         char *name = strtab + syms[i].st_name;
211                         if (name[0] == '.')
212                                 memmove(name, name+1, strlen(name));
213                 }
214         }
215 }
216
217 int module_frob_arch_sections(Elf64_Ehdr *hdr,
218                               Elf64_Shdr *sechdrs,
219                               char *secstrings,
220                               struct module *me)
221 {
222         unsigned int i;
223
224         /* Find .toc and .stubs sections, symtab and strtab */
225         for (i = 1; i < hdr->e_shnum; i++) {
226                 char *p;
227                 if (strcmp(secstrings + sechdrs[i].sh_name, ".stubs") == 0)
228                         me->arch.stubs_section = i;
229                 else if (strcmp(secstrings + sechdrs[i].sh_name, ".toc") == 0)
230                         me->arch.toc_section = i;
231                 else if (strcmp(secstrings+sechdrs[i].sh_name,"__versions")==0)
232                         dedotify_versions((void *)hdr + sechdrs[i].sh_offset,
233                                           sechdrs[i].sh_size);
234
235                 /* We don't handle .init for the moment: rename to _init */
236                 while ((p = strstr(secstrings + sechdrs[i].sh_name, ".init")))
237                         p[0] = '_';
238
239                 if (sechdrs[i].sh_type == SHT_SYMTAB)
240                         dedotify((void *)hdr + sechdrs[i].sh_offset,
241                                  sechdrs[i].sh_size / sizeof(Elf64_Sym),
242                                  (void *)hdr
243                                  + sechdrs[sechdrs[i].sh_link].sh_offset);
244         }
245
246         if (!me->arch.stubs_section) {
247                 printk("%s: doesn't contain .stubs.\n", me->name);
248                 return -ENOEXEC;
249         }
250
251         /* If we don't have a .toc, just use .stubs.  We need to set r2
252            to some reasonable value in case the module calls out to
253            other functions via a stub, or if a function pointer escapes
254            the module by some means.  */
255         if (!me->arch.toc_section)
256                 me->arch.toc_section = me->arch.stubs_section;
257
258         /* Override the stubs size */
259         sechdrs[me->arch.stubs_section].sh_size = get_stubs_size(hdr, sechdrs);
260         return 0;
261 }
262
263 int apply_relocate(Elf64_Shdr *sechdrs,
264                    const char *strtab,
265                    unsigned int symindex,
266                    unsigned int relsec,
267                    struct module *me)
268 {
269         printk(KERN_ERR "%s: Non-ADD RELOCATION unsupported\n", me->name);
270         return -ENOEXEC;
271 }
272
273 /* r2 is the TOC pointer: it actually points 0x8000 into the TOC (this
274    gives the value maximum span in an instruction which uses a signed
275    offset) */
276 static inline unsigned long my_r2(Elf64_Shdr *sechdrs, struct module *me)
277 {
278         return sechdrs[me->arch.toc_section].sh_addr + 0x8000;
279 }
280
281 /* Both low and high 16 bits are added as SIGNED additions, so if low
282    16 bits has high bit set, high 16 bits must be adjusted.  These
283    macros do that (stolen from binutils). */
284 #define PPC_LO(v) ((v) & 0xffff)
285 #define PPC_HI(v) (((v) >> 16) & 0xffff)
286 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
287
288 /* Patch stub to reference function and correct r2 value. */
289 static inline int create_stub(Elf64_Shdr *sechdrs,
290                               struct ppc64_stub_entry *entry,
291                               struct ppc64_opd_entry *opd,
292                               struct module *me)
293 {
294         Elf64_Half *loc1, *loc2;
295         long reladdr;
296
297         *entry = ppc64_stub;
298
299         loc1 = (Elf64_Half *)&entry->jump[2];
300         loc2 = (Elf64_Half *)&entry->jump[6];
301
302         /* Stub uses address relative to r2. */
303         reladdr = (unsigned long)entry - my_r2(sechdrs, me);
304         if (reladdr > 0x7FFFFFFF || reladdr < -(0x80000000L)) {
305                 printk("%s: Address %p of stub out of range of %p.\n",
306                        me->name, (void *)reladdr, (void *)my_r2);
307                 return 0;
308         }
309         DEBUGP("Stub %p get data from reladdr %li\n", entry, reladdr);
310
311         *loc1 = PPC_HA(reladdr);
312         *loc2 = PPC_LO(reladdr);
313         entry->opd.funcaddr = opd->funcaddr;
314         entry->opd.r2 = opd->r2;
315         return 1;
316 }
317
318 /* Create stub to jump to function described in this OPD: we need the
319    stub to set up the TOC ptr (r2) for the function. */
320 static unsigned long stub_for_addr(Elf64_Shdr *sechdrs,
321                                    unsigned long opdaddr,
322                                    struct module *me)
323 {
324         struct ppc64_stub_entry *stubs;
325         struct ppc64_opd_entry *opd = (void *)opdaddr;
326         unsigned int i, num_stubs;
327
328         num_stubs = sechdrs[me->arch.stubs_section].sh_size / sizeof(*stubs);
329
330         /* Find this stub, or if that fails, the next avail. entry */
331         stubs = (void *)sechdrs[me->arch.stubs_section].sh_addr;
332         for (i = 0; stubs[i].opd.funcaddr; i++) {
333                 BUG_ON(i >= num_stubs);
334
335                 if (stubs[i].opd.funcaddr == opd->funcaddr)
336                         return (unsigned long)&stubs[i];
337         }
338
339         if (!create_stub(sechdrs, &stubs[i], opd, me))
340                 return 0;
341
342         return (unsigned long)&stubs[i];
343 }
344
345 /* We expect a noop next: if it is, replace it with instruction to
346    restore r2. */
347 static int restore_r2(u32 *instruction, struct module *me)
348 {
349         if (*instruction != 0x60000000) {
350                 printk("%s: Expect noop after relocate, got %08x\n",
351                        me->name, *instruction);
352                 return 0;
353         }
354         *instruction = 0xe8410028;      /* ld r2,40(r1) */
355         return 1;
356 }
357
358 int apply_relocate_add(Elf64_Shdr *sechdrs,
359                        const char *strtab,
360                        unsigned int symindex,
361                        unsigned int relsec,
362                        struct module *me)
363 {
364         unsigned int i;
365         Elf64_Rela *rela = (void *)sechdrs[relsec].sh_addr;
366         Elf64_Sym *sym;
367         unsigned long *location;
368         unsigned long value;
369
370         DEBUGP("Applying ADD relocate section %u to %u\n", relsec,
371                sechdrs[relsec].sh_info);
372         for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rela); i++) {
373                 /* This is where to make the change */
374                 location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
375                         + rela[i].r_offset;
376                 /* This is the symbol it is referring to */
377                 sym = (Elf64_Sym *)sechdrs[symindex].sh_addr
378                         + ELF64_R_SYM(rela[i].r_info);
379
380                 DEBUGP("RELOC at %p: %li-type as %s (%lu) + %li\n",
381                        location, (long)ELF64_R_TYPE(rela[i].r_info),
382                        strtab + sym->st_name, (unsigned long)sym->st_value,
383                        (long)rela[i].r_addend);
384
385                 /* `Everything is relative'. */
386                 value = sym->st_value + rela[i].r_addend;
387
388                 switch (ELF64_R_TYPE(rela[i].r_info)) {
389                 case R_PPC64_ADDR32:
390                         /* Simply set it */
391                         *(u32 *)location = value;
392                         break;
393
394                 case R_PPC64_ADDR64:
395                         /* Simply set it */
396                         *(unsigned long *)location = value;
397                         break;
398
399                 case R_PPC64_TOC:
400                         *(unsigned long *)location = my_r2(sechdrs, me);
401                         break;
402
403                 case R_PPC64_TOC16:
404                         /* Subtract TOC pointer */
405                         value -= my_r2(sechdrs, me);
406                         if (value + 0x8000 > 0xffff) {
407                                 printk("%s: bad TOC16 relocation (%lu)\n",
408                                        me->name, value);
409                                 return -ENOEXEC;
410                         }
411                         *((uint16_t *) location)
412                                 = (*((uint16_t *) location) & ~0xffff)
413                                 | (value & 0xffff);
414                         break;
415
416                 case R_PPC64_TOC16_DS:
417                         /* Subtract TOC pointer */
418                         value -= my_r2(sechdrs, me);
419                         if ((value & 3) != 0 || value + 0x8000 > 0xffff) {
420                                 printk("%s: bad TOC16_DS relocation (%lu)\n",
421                                        me->name, value);
422                                 return -ENOEXEC;
423                         }
424                         *((uint16_t *) location)
425                                 = (*((uint16_t *) location) & ~0xfffc)
426                                 | (value & 0xfffc);
427                         break;
428
429                 case R_PPC_REL24:
430                         /* FIXME: Handle weak symbols here --RR */
431                         if (sym->st_shndx == SHN_UNDEF) {
432                                 /* External: go via stub */
433                                 value = stub_for_addr(sechdrs, value, me);
434                                 if (!value)
435                                         return -ENOENT;
436                                 if (!restore_r2((u32 *)location + 1, me))
437                                         return -ENOEXEC;
438                         }
439
440                         /* Convert value to relative */
441                         value -= (unsigned long)location;
442                         if (value + 0x2000000 > 0x3ffffff || (value & 3) != 0){
443                                 printk("%s: REL24 %li out of range!\n",
444                                        me->name, (long int)value);
445                                 return -ENOEXEC;
446                         }
447
448                         /* Only replace bits 2 through 26 */
449                         *(uint32_t *)location
450                                 = (*(uint32_t *)location & ~0x03fffffc)
451                                 | (value & 0x03fffffc);
452                         break;
453
454                 case R_PPC64_REL64:
455                         /* 64 bits relative (used by features fixups) */
456                         *location = value - (unsigned long)location;
457                         break;
458
459                 default:
460                         printk("%s: Unknown ADD relocation: %lu\n",
461                                me->name,
462                                (unsigned long)ELF64_R_TYPE(rela[i].r_info));
463                         return -ENOEXEC;
464                 }
465         }
466
467         return 0;
468 }
469
470 LIST_HEAD(module_bug_list);
471
472 static const Elf_Shdr *find_section(const Elf_Ehdr *hdr,
473                                     const Elf_Shdr *sechdrs,
474                                     const char *name)
475 {
476         char *secstrings;
477         unsigned int i;
478
479         secstrings = (char *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
480         for (i = 1; i < hdr->e_shnum; i++)
481                 if (strcmp(secstrings+sechdrs[i].sh_name, name) == 0)
482                         return &sechdrs[i];
483         return NULL;
484 }
485
486 int module_finalize(const Elf_Ehdr *hdr,
487                 const Elf_Shdr *sechdrs, struct module *me)
488 {
489         const Elf_Shdr *sect;
490         int err;
491
492         err = module_bug_finalize(hdr, sechdrs, me);
493         if (err)
494                 return err;
495
496         /* Apply feature fixups */
497         sect = find_section(hdr, sechdrs, "__ftr_fixup");
498         if (sect != NULL)
499                 do_feature_fixups(cur_cpu_spec->cpu_features,
500                                   (void *)sect->sh_addr,
501                                   (void *)sect->sh_addr + sect->sh_size);
502
503         sect = find_section(hdr, sechdrs, "__fw_ftr_fixup");
504         if (sect != NULL)
505                 do_feature_fixups(powerpc_firmware_features,
506                                   (void *)sect->sh_addr,
507                                   (void *)sect->sh_addr + sect->sh_size);
508
509         return 0;
510 }
511
512 void module_arch_cleanup(struct module *mod)
513 {
514         module_bug_cleanup(mod);
515 }
516
517 struct bug_entry *module_find_bug(unsigned long bugaddr)
518 {
519         struct mod_arch_specific *mod;
520         unsigned int i;
521         struct bug_entry *bug;
522
523         list_for_each_entry(mod, &module_bug_list, bug_list) {
524                 bug = mod->bug_table;
525                 for (i = 0; i < mod->num_bugs; ++i, ++bug)
526                         if (bugaddr == bug->bug_addr)
527                                 return bug;
528         }
529         return NULL;
530 }