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