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