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