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 <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
 106         return vmalloc_exec(size);
 107 }
 108
 109 /* Free memory returned from module_alloc */
 110 void module_free(struct module *mod, void *module_region)
 111 {
 112         vfree(module_region);
 113         /* FIXME: If module_region == mod->init_region, trim exception
 114            table entries. */
 115 }
 116
 117 /* Get size of potential trampolines required. */
 118 static unsigned long get_stubs_size(const Elf64_Ehdr *hdr,
 119                                     const Elf64_Shdr *sechdrs)
 120 {
 121         /* One extra reloc so it's always 0-funcaddr terminated */
 122         unsigned long relocs = 1;
 123         unsigned i;
 124
 125         /* Every relocated section... */
 126         for (i = 1; i < hdr->e_shnum; i++) {
 127                 if (sechdrs[i].sh_type == SHT_RELA) {
 128                         DEBUGP("Found relocations in section %u\n", i);
 129                         DEBUGP("Ptr: %p.  Number: %lu\n",
 130                                (void *)sechdrs[i].sh_addr,
 131                                sechdrs[i].sh_size / sizeof(Elf64_Rela));
 132                         relocs += count_relocs((void *)sechdrs[i].sh_addr,
 133                                                sechdrs[i].sh_size
 134                                                / sizeof(Elf64_Rela));
 135                 }
 136         }
 137
 138         DEBUGP("Looks like a total of %lu stubs, max\n", relocs);
 139         return relocs * sizeof(struct ppc64_stub_entry);
 140 }
 141
 142 static void dedotify_versions(struct modversion_info *vers,
 143                               unsigned long size)
 144 {
 145         struct modversion_info *end;
 146
 147         for (end = (void *)vers + size; vers < end; vers++)
 148                 if (vers->name[0] == '.')
 149                         memmove(vers->name, vers->name+1, strlen(vers->name));
 150 }
 151
 152 /* Undefined symbols which refer to .funcname, hack to funcname */
 153 static void dedotify(Elf64_Sym *syms, unsigned int numsyms, char *strtab)
 154 {
 155         unsigned int i;
 156
 157         for (i = 1; i < numsyms; i++) {
 158                 if (syms[i].st_shndx == SHN_UNDEF) {
 159                         char *name = strtab + syms[i].st_name;
 160                         if (name[0] == '.')
 161                                 memmove(name, name+1, strlen(name));
 162                 }
 163         }
 164 }
 165
 166 int module_frob_arch_sections(Elf64_Ehdr *hdr,
 167                               Elf64_Shdr *sechdrs,
 168                               char *secstrings,
 169                               struct module *me)
 170 {
 171         unsigned int i;
 172
 173         /* Find .toc and .stubs sections, symtab and strtab */
 174         for (i = 1; i < hdr->e_shnum; i++) {
 175                 char *p;
 176                 if (strcmp(secstrings + sechdrs[i].sh_name, ".stubs") == 0)
 177                         me->arch.stubs_section = i;
 178                 else if (strcmp(secstrings + sechdrs[i].sh_name, ".toc") == 0)
 179                         me->arch.toc_section = i;
 180                 else if (strcmp(secstrings+sechdrs[i].sh_name,"__versions")==0)
 181                         dedotify_versions((void *)hdr + sechdrs[i].sh_offset,
 182                                           sechdrs[i].sh_size);
 183
 184                 /* We don't handle .init for the moment: rename to _init */
 185                 while ((p = strstr(secstrings + sechdrs[i].sh_name, ".init")))
 186                         p[0] = '_';
 187
 188                 if (sechdrs[i].sh_type == SHT_SYMTAB)
 189                         dedotify((void *)hdr + sechdrs[i].sh_offset,
 190                                  sechdrs[i].sh_size / sizeof(Elf64_Sym),
 191                                  (void *)hdr
 192                                  + sechdrs[sechdrs[i].sh_link].sh_offset);
 193         }
 194
 195         if (!me->arch.stubs_section) {
 196                 printk("%s: doesn't contain .stubs.\n", me->name);
 197                 return -ENOEXEC;
 198         }
 199
 200         /* If we don't have a .toc, just use .stubs.  We need to set r2
 201            to some reasonable value in case the module calls out to
 202            other functions via a stub, or if a function pointer escapes
 203            the module by some means.  */
 204         if (!me->arch.toc_section)
 205                 me->arch.toc_section = me->arch.stubs_section;
 206
 207         /* Override the stubs size */
 208         sechdrs[me->arch.stubs_section].sh_size = get_stubs_size(hdr, sechdrs);
 209         return 0;
 210 }
 211
 212 int apply_relocate(Elf64_Shdr *sechdrs,
 213                    const char *strtab,
 214                    unsigned int symindex,
 215                    unsigned int relsec,
 216                    struct module *me)
 217 {
 218         printk(KERN_ERR "%s: Non-ADD RELOCATION unsupported\n", me->name);
 219         return -ENOEXEC;
 220 }
 221
 222 /* r2 is the TOC pointer: it actually points 0x8000 into the TOC (this
 223    gives the value maximum span in an instruction which uses a signed
 224    offset) */
 225 static inline unsigned long my_r2(Elf64_Shdr *sechdrs, struct module *me)
 226 {
 227         return sechdrs[me->arch.toc_section].sh_addr + 0x8000;
 228 }
 229
 230 /* Both low and high 16 bits are added as SIGNED additions, so if low
 231    16 bits has high bit set, high 16 bits must be adjusted.  These
 232    macros do that (stolen from binutils). */
 233 #define PPC_LO(v) ((v) & 0xffff)
 234 #define PPC_HI(v) (((v) >> 16) & 0xffff)
 235 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
 236
 237 /* Patch stub to reference function and correct r2 value. */
 238 static inline int create_stub(Elf64_Shdr *sechdrs,
 239                               struct ppc64_stub_entry *entry,
 240                               struct ppc64_opd_entry *opd,
 241                               struct module *me)
 242 {
 243         Elf64_Half *loc1, *loc2;
 244         long reladdr;
 245
 246         *entry = ppc64_stub;
 247
 248         loc1 = (Elf64_Half *)&entry->jump[2];
 249         loc2 = (Elf64_Half *)&entry->jump[6];
 250
 251         /* Stub uses address relative to r2. */
 252         reladdr = (unsigned long)entry - my_r2(sechdrs, me);
 253         if (reladdr > 0x7FFFFFFF || reladdr < -(0x80000000L)) {
 254                 printk("%s: Address %p of stub out of range of %p.\n",
 255                        me->name, (void *)reladdr, (void *)my_r2);
 256                 return 0;
 257         }
 258         DEBUGP("Stub %p get data from reladdr %li\n", entry, reladdr);
 259
 260         *loc1 = PPC_HA(reladdr);
 261         *loc2 = PPC_LO(reladdr);
 262         entry->opd.funcaddr = opd->funcaddr;
 263         entry->opd.r2 = opd->r2;
 264         return 1;
 265 }
 266
 267 /* Create stub to jump to function described in this OPD: we need the
 268    stub to set up the TOC ptr (r2) for the function. */
 269 static unsigned long stub_for_addr(Elf64_Shdr *sechdrs,
 270                                    unsigned long opdaddr,
 271                                    struct module *me)
 272 {
 273         struct ppc64_stub_entry *stubs;
 274         struct ppc64_opd_entry *opd = (void *)opdaddr;
 275         unsigned int i, num_stubs;
 276
 277         num_stubs = sechdrs[me->arch.stubs_section].sh_size / sizeof(*stubs);
 278
 279         /* Find this stub, or if that fails, the next avail. entry */
 280         stubs = (void *)sechdrs[me->arch.stubs_section].sh_addr;
 281         for (i = 0; stubs[i].opd.funcaddr; i++) {
 282                 BUG_ON(i >= num_stubs);
 283
 284                 if (stubs[i].opd.funcaddr == opd->funcaddr)
 285                         return (unsigned long)&stubs[i];
 286         }
 287
 288         if (!create_stub(sechdrs, &stubs[i], opd, me))
 289                 return 0;
 290
 291         return (unsigned long)&stubs[i];
 292 }
 293
 294 /* We expect a noop next: if it is, replace it with instruction to
 295    restore r2. */
 296 static int restore_r2(u32 *instruction, struct module *me)
 297 {
 298         if (*instruction != 0x60000000) {
 299                 printk("%s: Expect noop after relocate, got %08x\n",
 300                        me->name, *instruction);
 301                 return 0;
 302         }
 303         *instruction = 0xe8410028;      /* ld r2,40(r1) */
 304         return 1;
 305 }
 306
 307 int apply_relocate_add(Elf64_Shdr *sechdrs,
 308                        const char *strtab,
 309                        unsigned int symindex,
 310                        unsigned int relsec,
 311                        struct module *me)
 312 {
 313         unsigned int i;
 314         Elf64_Rela *rela = (void *)sechdrs[relsec].sh_addr;
 315         Elf64_Sym *sym;
 316         unsigned long *location;
 317         unsigned long value;
 318
 319         DEBUGP("Applying ADD relocate section %u to %u\n", relsec,
 320                sechdrs[relsec].sh_info);
 321         for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rela); i++) {
 322                 /* This is where to make the change */
 323                 location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
 324                         + rela[i].r_offset;
 325                 /* This is the symbol it is referring to */
 326                 sym = (Elf64_Sym *)sechdrs[symindex].sh_addr
 327                         + ELF64_R_SYM(rela[i].r_info);
 328
 329                 DEBUGP("RELOC at %p: %li-type as %s (%lu) + %li\n",
 330                        location, (long)ELF64_R_TYPE(rela[i].r_info),
 331                        strtab + sym->st_name, (unsigned long)sym->st_value,
 332                        (long)rela[i].r_addend);
 333
 334                 /* `Everything is relative'. */
 335                 value = sym->st_value + rela[i].r_addend;
 336
 337                 switch (ELF64_R_TYPE(rela[i].r_info)) {
 338                 case R_PPC64_ADDR32:
 339                         /* Simply set it */
 340                         *(u32 *)location = value;
 341                         break;
 342
 343                 case R_PPC64_ADDR64:
 344                         /* Simply set it */
 345                         *(unsigned long *)location = value;
 346                         break;
 347
 348                 case R_PPC64_TOC:
 349                         *(unsigned long *)location = my_r2(sechdrs, me);
 350                         break;
 351
 352                 case R_PPC64_TOC16:
 353                         /* Subtract TOC pointer */
 354                         value -= my_r2(sechdrs, me);
 355                         if (value + 0x8000 > 0xffff) {
 356                                 printk("%s: bad TOC16 relocation (%lu)\n",
 357                                        me->name, value);
 358                                 return -ENOEXEC;
 359                         }
 360                         *((uint16_t *) location)
 361                                 = (*((uint16_t *) location) & ~0xffff)
 362                                 | (value & 0xffff);
 363                         break;
 364
 365                 case R_PPC64_TOC16_DS:
 366                         /* Subtract TOC pointer */
 367                         value -= my_r2(sechdrs, me);
 368                         if ((value & 3) != 0 || value + 0x8000 > 0xffff) {
 369                                 printk("%s: bad TOC16_DS relocation (%lu)\n",
 370                                        me->name, value);
 371                                 return -ENOEXEC;
 372                         }
 373                         *((uint16_t *) location)
 374                                 = (*((uint16_t *) location) & ~0xfffc)
 375                                 | (value & 0xfffc);
 376                         break;
 377
 378                 case R_PPC_REL24:
 379                         /* FIXME: Handle weak symbols here --RR */
 380                         if (sym->st_shndx == SHN_UNDEF) {
 381                                 /* External: go via stub */
 382                                 value = stub_for_addr(sechdrs, value, me);
 383                                 if (!value)
 384                                         return -ENOENT;
 385                                 if (!restore_r2((u32 *)location + 1, me))
 386                                         return -ENOEXEC;
 387                         }
 388
 389                         /* Convert value to relative */
 390                         value -= (unsigned long)location;
 391                         if (value + 0x2000000 > 0x3ffffff || (value & 3) != 0){
 392                                 printk("%s: REL24 %li out of range!\n",
 393                                        me->name, (long int)value);
 394                                 return -ENOEXEC;
 395                         }
 396
 397                         /* Only replace bits 2 through 26 */
 398                         *(uint32_t *)location
 399                                 = (*(uint32_t *)location & ~0x03fffffc)
 400                                 | (value & 0x03fffffc);
 401                         break;
 402
 403                 default:
 404                         printk("%s: Unknown ADD relocation: %lu\n",
 405                                me->name,
 406                                (unsigned long)ELF64_R_TYPE(rela[i].r_info));
 407                         return -ENOEXEC;
 408                 }
 409         }
 410
 411         return 0;
 412 }
 413
 414 LIST_HEAD(module_bug_list);
 415
 416 int module_finalize(const Elf_Ehdr *hdr,
 417                 const Elf_Shdr *sechdrs, struct module *me)
 418 {
 419         char *secstrings;
 420         unsigned int i;
 421
 422         me->arch.bug_table = NULL;
 423         me->arch.num_bugs = 0;
 424
 425         /* Find the __bug_table section, if present */
 426         secstrings = (char *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
 427         for (i = 1; i < hdr->e_shnum; i++) {
 428                 if (strcmp(secstrings+sechdrs[i].sh_name, "__bug_table"))
 429                         continue;
 430                 me->arch.bug_table = (void *) sechdrs[i].sh_addr;
 431                 me->arch.num_bugs = sechdrs[i].sh_size / sizeof(struct bug_entry);
 432                 break;
 433         }
 434
 435         /*
 436          * Strictly speaking this should have a spinlock to protect against
 437          * traversals, but since we only traverse on BUG()s, a spinlock
 438          * could potentially lead to deadlock and thus be counter-productive.
 439          */
 440         list_add(&me->arch.bug_list, &module_bug_list);
 441
 442         return 0;
 443 }
 444
 445 void module_arch_cleanup(struct module *mod)
 446 {
 447         list_del(&mod->arch.bug_list);
 448 }
 449
 450 struct bug_entry *module_find_bug(unsigned long bugaddr)
 451 {
 452         struct mod_arch_specific *mod;
 453         unsigned int i;
 454         struct bug_entry *bug;
 455
 456         list_for_each_entry(mod, &module_bug_list, bug_list) {
 457                 bug = mod->bug_table;
 458                 for (i = 0; i < mod->num_bugs; ++i, ++bug)
 459                         if (bugaddr == bug->bug_addr)
 460                                 return bug;
 461         }
 462         return NULL;
 463 }