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