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