linux/arch/parisc/kernel/module.c
<<
>>
Prefs
   1/*    Kernel dynamically loadable module help for PARISC.
   2 *
   3 *    The best reference for this stuff is probably the Processor-
   4 *    Specific ELF Supplement for PA-RISC:
   5 *        http://ftp.parisc-linux.org/docs/arch/elf-pa-hp.pdf
   6 *
   7 *    Linux/PA-RISC Project (http://www.parisc-linux.org/)
   8 *    Copyright (C) 2003 Randolph Chung <tausq at debian . org>
   9 *    Copyright (C) 2008 Helge Deller <deller@gmx.de>
  10 *
  11 *
  12 *    This program is free software; you can redistribute it and/or modify
  13 *    it under the terms of the GNU General Public License as published by
  14 *    the Free Software Foundation; either version 2 of the License, or
  15 *    (at your option) any later version.
  16 *
  17 *    This program is distributed in the hope that it will be useful,
  18 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 *    GNU General Public License for more details.
  21 *
  22 *    You should have received a copy of the GNU General Public License
  23 *    along with this program; if not, write to the Free Software
  24 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25 *
  26 *
  27 *    Notes:
  28 *    - PLT stub handling
  29 *      On 32bit (and sometimes 64bit) and with big kernel modules like xfs or
  30 *      ipv6 the relocation types R_PARISC_PCREL17F and R_PARISC_PCREL22F may
  31 *      fail to reach their PLT stub if we only create one big stub array for
  32 *      all sections at the beginning of the core or init section.
  33 *      Instead we now insert individual PLT stub entries directly in front of
  34 *      of the code sections where the stubs are actually called.
  35 *      This reduces the distance between the PCREL location and the stub entry
  36 *      so that the relocations can be fulfilled.
  37 *      While calculating the final layout of the kernel module in memory, the
  38 *      kernel module loader calls arch_mod_section_prepend() to request the
  39 *      to be reserved amount of memory in front of each individual section.
  40 *
  41 *    - SEGREL32 handling
  42 *      We are not doing SEGREL32 handling correctly. According to the ABI, we
  43 *      should do a value offset, like this:
  44 *                      if (in_init(me, (void *)val))
  45 *                              val -= (uint32_t)me->module_init;
  46 *                      else
  47 *                              val -= (uint32_t)me->module_core;
  48 *      However, SEGREL32 is used only for PARISC unwind entries, and we want
  49 *      those entries to have an absolute address, and not just an offset.
  50 *
  51 *      The unwind table mechanism has the ability to specify an offset for 
  52 *      the unwind table; however, because we split off the init functions into
  53 *      a different piece of memory, it is not possible to do this using a 
  54 *      single offset. Instead, we use the above hack for now.
  55 */
  56
  57#include <linux/moduleloader.h>
  58#include <linux/elf.h>
  59#include <linux/vmalloc.h>
  60#include <linux/fs.h>
  61#include <linux/string.h>
  62#include <linux/kernel.h>
  63#include <linux/bug.h>
  64#include <linux/mm.h>
  65#include <linux/slab.h>
  66
  67#include <asm/pgtable.h>
  68#include <asm/unwind.h>
  69
  70#if 0
  71#define DEBUGP printk
  72#else
  73#define DEBUGP(fmt...)
  74#endif
  75
  76#define RELOC_REACHABLE(val, bits) \
  77        (( ( !((val) & (1<<((bits)-1))) && ((val)>>(bits)) != 0 )  ||   \
  78             ( ((val) & (1<<((bits)-1))) && ((val)>>(bits)) != (((__typeof__(val))(~0))>>((bits)+2)))) ? \
  79        0 : 1)
  80
  81#define CHECK_RELOC(val, bits) \
  82        if (!RELOC_REACHABLE(val, bits)) { \
  83                printk(KERN_ERR "module %s relocation of symbol %s is out of range (0x%lx in %d bits)\n", \
  84                me->name, strtab + sym->st_name, (unsigned long)val, bits); \
  85                return -ENOEXEC;                        \
  86        }
  87
  88/* Maximum number of GOT entries. We use a long displacement ldd from
  89 * the bottom of the table, which has a maximum signed displacement of
  90 * 0x3fff; however, since we're only going forward, this becomes
  91 * 0x1fff, and thus, since each GOT entry is 8 bytes long we can have
  92 * at most 1023 entries.
  93 * To overcome this 14bit displacement with some kernel modules, we'll
  94 * use instead the unusal 16bit displacement method (see reassemble_16a)
  95 * which gives us a maximum positive displacement of 0x7fff, and as such
  96 * allows us to allocate up to 4095 GOT entries. */
  97#define MAX_GOTS        4095
  98
  99/* three functions to determine where in the module core
 100 * or init pieces the location is */
 101static inline int in_init(struct module *me, void *loc)
 102{
 103        return (loc >= me->module_init &&
 104                loc <= (me->module_init + me->init_size));
 105}
 106
 107static inline int in_core(struct module *me, void *loc)
 108{
 109        return (loc >= me->module_core &&
 110                loc <= (me->module_core + me->core_size));
 111}
 112
 113static inline int in_local(struct module *me, void *loc)
 114{
 115        return in_init(me, loc) || in_core(me, loc);
 116}
 117
 118#ifndef CONFIG_64BIT
 119struct got_entry {
 120        Elf32_Addr addr;
 121};
 122
 123struct stub_entry {
 124        Elf32_Word insns[2]; /* each stub entry has two insns */
 125};
 126#else
 127struct got_entry {
 128        Elf64_Addr addr;
 129};
 130
 131struct stub_entry {
 132        Elf64_Word insns[4]; /* each stub entry has four insns */
 133};
 134#endif
 135
 136/* Field selection types defined by hppa */
 137#define rnd(x)                  (((x)+0x1000)&~0x1fff)
 138/* fsel: full 32 bits */
 139#define fsel(v,a)               ((v)+(a))
 140/* lsel: select left 21 bits */
 141#define lsel(v,a)               (((v)+(a))>>11)
 142/* rsel: select right 11 bits */
 143#define rsel(v,a)               (((v)+(a))&0x7ff)
 144/* lrsel with rounding of addend to nearest 8k */
 145#define lrsel(v,a)              (((v)+rnd(a))>>11)
 146/* rrsel with rounding of addend to nearest 8k */
 147#define rrsel(v,a)              ((((v)+rnd(a))&0x7ff)+((a)-rnd(a)))
 148
 149#define mask(x,sz)              ((x) & ~((1<<(sz))-1))
 150
 151
 152/* The reassemble_* functions prepare an immediate value for
 153   insertion into an opcode. pa-risc uses all sorts of weird bitfields
 154   in the instruction to hold the value.  */
 155static inline int sign_unext(int x, int len)
 156{
 157        int len_ones;
 158
 159        len_ones = (1 << len) - 1;
 160        return x & len_ones;
 161}
 162
 163static inline int low_sign_unext(int x, int len)
 164{
 165        int sign, temp;
 166
 167        sign = (x >> (len-1)) & 1;
 168        temp = sign_unext(x, len-1);
 169        return (temp << 1) | sign;
 170}
 171
 172static inline int reassemble_14(int as14)
 173{
 174        return (((as14 & 0x1fff) << 1) |
 175                ((as14 & 0x2000) >> 13));
 176}
 177
 178static inline int reassemble_16a(int as16)
 179{
 180        int s, t;
 181
 182        /* Unusual 16-bit encoding, for wide mode only.  */
 183        t = (as16 << 1) & 0xffff;
 184        s = (as16 & 0x8000);
 185        return (t ^ s ^ (s >> 1)) | (s >> 15);
 186}
 187
 188
 189static inline int reassemble_17(int as17)
 190{
 191        return (((as17 & 0x10000) >> 16) |
 192                ((as17 & 0x0f800) << 5) |
 193                ((as17 & 0x00400) >> 8) |
 194                ((as17 & 0x003ff) << 3));
 195}
 196
 197static inline int reassemble_21(int as21)
 198{
 199        return (((as21 & 0x100000) >> 20) |
 200                ((as21 & 0x0ffe00) >> 8) |
 201                ((as21 & 0x000180) << 7) |
 202                ((as21 & 0x00007c) << 14) |
 203                ((as21 & 0x000003) << 12));
 204}
 205
 206static inline int reassemble_22(int as22)
 207{
 208        return (((as22 & 0x200000) >> 21) |
 209                ((as22 & 0x1f0000) << 5) |
 210                ((as22 & 0x00f800) << 5) |
 211                ((as22 & 0x000400) >> 8) |
 212                ((as22 & 0x0003ff) << 3));
 213}
 214
 215void *module_alloc(unsigned long size)
 216{
 217        /* using RWX means less protection for modules, but it's
 218         * easier than trying to map the text, data, init_text and
 219         * init_data correctly */
 220        return __vmalloc_node_range(size, 1, VMALLOC_START, VMALLOC_END,
 221                                    GFP_KERNEL | __GFP_HIGHMEM,
 222                                    PAGE_KERNEL_RWX, 0, NUMA_NO_NODE,
 223                                    __builtin_return_address(0));
 224}
 225
 226#ifndef CONFIG_64BIT
 227static inline unsigned long count_gots(const Elf_Rela *rela, unsigned long n)
 228{
 229        return 0;
 230}
 231
 232static inline unsigned long count_fdescs(const Elf_Rela *rela, unsigned long n)
 233{
 234        return 0;
 235}
 236
 237static inline unsigned long count_stubs(const Elf_Rela *rela, unsigned long n)
 238{
 239        unsigned long cnt = 0;
 240
 241        for (; n > 0; n--, rela++)
 242        {
 243                switch (ELF32_R_TYPE(rela->r_info)) {
 244                        case R_PARISC_PCREL17F:
 245                        case R_PARISC_PCREL22F:
 246                                cnt++;
 247                }
 248        }
 249
 250        return cnt;
 251}
 252#else
 253static inline unsigned long count_gots(const Elf_Rela *rela, unsigned long n)
 254{
 255        unsigned long cnt = 0;
 256
 257        for (; n > 0; n--, rela++)
 258        {
 259                switch (ELF64_R_TYPE(rela->r_info)) {
 260                        case R_PARISC_LTOFF21L:
 261                        case R_PARISC_LTOFF14R:
 262                        case R_PARISC_PCREL22F:
 263                                cnt++;
 264                }
 265        }
 266
 267        return cnt;
 268}
 269
 270static inline unsigned long count_fdescs(const Elf_Rela *rela, unsigned long n)
 271{
 272        unsigned long cnt = 0;
 273
 274        for (; n > 0; n--, rela++)
 275        {
 276                switch (ELF64_R_TYPE(rela->r_info)) {
 277                        case R_PARISC_FPTR64:
 278                                cnt++;
 279                }
 280        }
 281
 282        return cnt;
 283}
 284
 285static inline unsigned long count_stubs(const Elf_Rela *rela, unsigned long n)
 286{
 287        unsigned long cnt = 0;
 288
 289        for (; n > 0; n--, rela++)
 290        {
 291                switch (ELF64_R_TYPE(rela->r_info)) {
 292                        case R_PARISC_PCREL22F:
 293                                cnt++;
 294                }
 295        }
 296
 297        return cnt;
 298}
 299#endif
 300
 301void module_arch_freeing_init(struct module *mod)
 302{
 303        kfree(mod->arch.section);
 304        mod->arch.section = NULL;
 305}
 306
 307/* Additional bytes needed in front of individual sections */
 308unsigned int arch_mod_section_prepend(struct module *mod,
 309                                      unsigned int section)
 310{
 311        /* size needed for all stubs of this section (including
 312         * one additional for correct alignment of the stubs) */
 313        return (mod->arch.section[section].stub_entries + 1)
 314                * sizeof(struct stub_entry);
 315}
 316
 317#define CONST 
 318int module_frob_arch_sections(CONST Elf_Ehdr *hdr,
 319                              CONST Elf_Shdr *sechdrs,
 320                              CONST char *secstrings,
 321                              struct module *me)
 322{
 323        unsigned long gots = 0, fdescs = 0, len;
 324        unsigned int i;
 325
 326        len = hdr->e_shnum * sizeof(me->arch.section[0]);
 327        me->arch.section = kzalloc(len, GFP_KERNEL);
 328        if (!me->arch.section)
 329                return -ENOMEM;
 330
 331        for (i = 1; i < hdr->e_shnum; i++) {
 332                const Elf_Rela *rels = (void *)sechdrs[i].sh_addr;
 333                unsigned long nrels = sechdrs[i].sh_size / sizeof(*rels);
 334                unsigned int count, s;
 335
 336                if (strncmp(secstrings + sechdrs[i].sh_name,
 337                            ".PARISC.unwind", 14) == 0)
 338                        me->arch.unwind_section = i;
 339
 340                if (sechdrs[i].sh_type != SHT_RELA)
 341                        continue;
 342
 343                /* some of these are not relevant for 32-bit/64-bit
 344                 * we leave them here to make the code common. the
 345                 * compiler will do its thing and optimize out the
 346                 * stuff we don't need
 347                 */
 348                gots += count_gots(rels, nrels);
 349                fdescs += count_fdescs(rels, nrels);
 350
 351                /* XXX: By sorting the relocs and finding duplicate entries
 352                 *  we could reduce the number of necessary stubs and save
 353                 *  some memory. */
 354                count = count_stubs(rels, nrels);
 355                if (!count)
 356                        continue;
 357
 358                /* so we need relocation stubs. reserve necessary memory. */
 359                /* sh_info gives the section for which we need to add stubs. */
 360                s = sechdrs[i].sh_info;
 361
 362                /* each code section should only have one relocation section */
 363                WARN_ON(me->arch.section[s].stub_entries);
 364
 365                /* store number of stubs we need for this section */
 366                me->arch.section[s].stub_entries += count;
 367        }
 368
 369        /* align things a bit */
 370        me->core_size = ALIGN(me->core_size, 16);
 371        me->arch.got_offset = me->core_size;
 372        me->core_size += gots * sizeof(struct got_entry);
 373
 374        me->core_size = ALIGN(me->core_size, 16);
 375        me->arch.fdesc_offset = me->core_size;
 376        me->core_size += fdescs * sizeof(Elf_Fdesc);
 377
 378        me->arch.got_max = gots;
 379        me->arch.fdesc_max = fdescs;
 380
 381        return 0;
 382}
 383
 384#ifdef CONFIG_64BIT
 385static Elf64_Word get_got(struct module *me, unsigned long value, long addend)
 386{
 387        unsigned int i;
 388        struct got_entry *got;
 389
 390        value += addend;
 391
 392        BUG_ON(value == 0);
 393
 394        got = me->module_core + me->arch.got_offset;
 395        for (i = 0; got[i].addr; i++)
 396                if (got[i].addr == value)
 397                        goto out;
 398
 399        BUG_ON(++me->arch.got_count > me->arch.got_max);
 400
 401        got[i].addr = value;
 402 out:
 403        DEBUGP("GOT ENTRY %d[%x] val %lx\n", i, i*sizeof(struct got_entry),
 404               value);
 405        return i * sizeof(struct got_entry);
 406}
 407#endif /* CONFIG_64BIT */
 408
 409#ifdef CONFIG_64BIT
 410static Elf_Addr get_fdesc(struct module *me, unsigned long value)
 411{
 412        Elf_Fdesc *fdesc = me->module_core + me->arch.fdesc_offset;
 413
 414        if (!value) {
 415                printk(KERN_ERR "%s: zero OPD requested!\n", me->name);
 416                return 0;
 417        }
 418
 419        /* Look for existing fdesc entry. */
 420        while (fdesc->addr) {
 421                if (fdesc->addr == value)
 422                        return (Elf_Addr)fdesc;
 423                fdesc++;
 424        }
 425
 426        BUG_ON(++me->arch.fdesc_count > me->arch.fdesc_max);
 427
 428        /* Create new one */
 429        fdesc->addr = value;
 430        fdesc->gp = (Elf_Addr)me->module_core + me->arch.got_offset;
 431        return (Elf_Addr)fdesc;
 432}
 433#endif /* CONFIG_64BIT */
 434
 435enum elf_stub_type {
 436        ELF_STUB_GOT,
 437        ELF_STUB_MILLI,
 438        ELF_STUB_DIRECT,
 439};
 440
 441static Elf_Addr get_stub(struct module *me, unsigned long value, long addend,
 442        enum elf_stub_type stub_type, Elf_Addr loc0, unsigned int targetsec)
 443{
 444        struct stub_entry *stub;
 445        int __maybe_unused d;
 446
 447        /* initialize stub_offset to point in front of the section */
 448        if (!me->arch.section[targetsec].stub_offset) {
 449                loc0 -= (me->arch.section[targetsec].stub_entries + 1) *
 450                                sizeof(struct stub_entry);
 451                /* get correct alignment for the stubs */
 452                loc0 = ALIGN(loc0, sizeof(struct stub_entry));
 453                me->arch.section[targetsec].stub_offset = loc0;
 454        }
 455
 456        /* get address of stub entry */
 457        stub = (void *) me->arch.section[targetsec].stub_offset;
 458        me->arch.section[targetsec].stub_offset += sizeof(struct stub_entry);
 459
 460        /* do not write outside available stub area */
 461        BUG_ON(0 == me->arch.section[targetsec].stub_entries--);
 462
 463
 464#ifndef CONFIG_64BIT
 465/* for 32-bit the stub looks like this:
 466 *      ldil L'XXX,%r1
 467 *      be,n R'XXX(%sr4,%r1)
 468 */
 469        //value = *(unsigned long *)((value + addend) & ~3); /* why? */
 470
 471        stub->insns[0] = 0x20200000;    /* ldil L'XXX,%r1       */
 472        stub->insns[1] = 0xe0202002;    /* be,n R'XXX(%sr4,%r1) */
 473
 474        stub->insns[0] |= reassemble_21(lrsel(value, addend));
 475        stub->insns[1] |= reassemble_17(rrsel(value, addend) / 4);
 476
 477#else
 478/* for 64-bit we have three kinds of stubs:
 479 * for normal function calls:
 480 *      ldd 0(%dp),%dp
 481 *      ldd 10(%dp), %r1
 482 *      bve (%r1)
 483 *      ldd 18(%dp), %dp
 484 *
 485 * for millicode:
 486 *      ldil 0, %r1
 487 *      ldo 0(%r1), %r1
 488 *      ldd 10(%r1), %r1
 489 *      bve,n (%r1)
 490 *
 491 * for direct branches (jumps between different section of the
 492 * same module):
 493 *      ldil 0, %r1
 494 *      ldo 0(%r1), %r1
 495 *      bve,n (%r1)
 496 */
 497        switch (stub_type) {
 498        case ELF_STUB_GOT:
 499                d = get_got(me, value, addend);
 500                if (d <= 15) {
 501                        /* Format 5 */
 502                        stub->insns[0] = 0x0f6010db; /* ldd 0(%dp),%dp  */
 503                        stub->insns[0] |= low_sign_unext(d, 5) << 16;
 504                } else {
 505                        /* Format 3 */
 506                        stub->insns[0] = 0x537b0000; /* ldd 0(%dp),%dp  */
 507                        stub->insns[0] |= reassemble_16a(d);
 508                }
 509                stub->insns[1] = 0x53610020;    /* ldd 10(%dp),%r1      */
 510                stub->insns[2] = 0xe820d000;    /* bve (%r1)            */
 511                stub->insns[3] = 0x537b0030;    /* ldd 18(%dp),%dp      */
 512                break;
 513        case ELF_STUB_MILLI:
 514                stub->insns[0] = 0x20200000;    /* ldil 0,%r1           */
 515                stub->insns[1] = 0x34210000;    /* ldo 0(%r1), %r1      */
 516                stub->insns[2] = 0x50210020;    /* ldd 10(%r1),%r1      */
 517                stub->insns[3] = 0xe820d002;    /* bve,n (%r1)          */
 518
 519                stub->insns[0] |= reassemble_21(lrsel(value, addend));
 520                stub->insns[1] |= reassemble_14(rrsel(value, addend));
 521                break;
 522        case ELF_STUB_DIRECT:
 523                stub->insns[0] = 0x20200000;    /* ldil 0,%r1           */
 524                stub->insns[1] = 0x34210000;    /* ldo 0(%r1), %r1      */
 525                stub->insns[2] = 0xe820d002;    /* bve,n (%r1)          */
 526
 527                stub->insns[0] |= reassemble_21(lrsel(value, addend));
 528                stub->insns[1] |= reassemble_14(rrsel(value, addend));
 529                break;
 530        }
 531
 532#endif
 533
 534        return (Elf_Addr)stub;
 535}
 536
 537#ifndef CONFIG_64BIT
 538int apply_relocate_add(Elf_Shdr *sechdrs,
 539                       const char *strtab,
 540                       unsigned int symindex,
 541                       unsigned int relsec,
 542                       struct module *me)
 543{
 544        int i;
 545        Elf32_Rela *rel = (void *)sechdrs[relsec].sh_addr;
 546        Elf32_Sym *sym;
 547        Elf32_Word *loc;
 548        Elf32_Addr val;
 549        Elf32_Sword addend;
 550        Elf32_Addr dot;
 551        Elf_Addr loc0;
 552        unsigned int targetsec = sechdrs[relsec].sh_info;
 553        //unsigned long dp = (unsigned long)$global$;
 554        register unsigned long dp asm ("r27");
 555
 556        DEBUGP("Applying relocate section %u to %u\n", relsec,
 557               targetsec);
 558        for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
 559                /* This is where to make the change */
 560                loc = (void *)sechdrs[targetsec].sh_addr
 561                      + rel[i].r_offset;
 562                /* This is the start of the target section */
 563                loc0 = sechdrs[targetsec].sh_addr;
 564                /* This is the symbol it is referring to */
 565                sym = (Elf32_Sym *)sechdrs[symindex].sh_addr
 566                        + ELF32_R_SYM(rel[i].r_info);
 567                if (!sym->st_value) {
 568                        printk(KERN_WARNING "%s: Unknown symbol %s\n",
 569                               me->name, strtab + sym->st_name);
 570                        return -ENOENT;
 571                }
 572                //dot = (sechdrs[relsec].sh_addr + rel->r_offset) & ~0x03;
 573                dot =  (Elf32_Addr)loc & ~0x03;
 574
 575                val = sym->st_value;
 576                addend = rel[i].r_addend;
 577
 578#if 0
 579#define r(t) ELF32_R_TYPE(rel[i].r_info)==t ? #t :
 580                DEBUGP("Symbol %s loc 0x%x val 0x%x addend 0x%x: %s\n",
 581                        strtab + sym->st_name,
 582                        (uint32_t)loc, val, addend,
 583                        r(R_PARISC_PLABEL32)
 584                        r(R_PARISC_DIR32)
 585                        r(R_PARISC_DIR21L)
 586                        r(R_PARISC_DIR14R)
 587                        r(R_PARISC_SEGREL32)
 588                        r(R_PARISC_DPREL21L)
 589                        r(R_PARISC_DPREL14R)
 590                        r(R_PARISC_PCREL17F)
 591                        r(R_PARISC_PCREL22F)
 592                        "UNKNOWN");
 593#undef r
 594#endif
 595
 596                switch (ELF32_R_TYPE(rel[i].r_info)) {
 597                case R_PARISC_PLABEL32:
 598                        /* 32-bit function address */
 599                        /* no function descriptors... */
 600                        *loc = fsel(val, addend);
 601                        break;
 602                case R_PARISC_DIR32:
 603                        /* direct 32-bit ref */
 604                        *loc = fsel(val, addend);
 605                        break;
 606                case R_PARISC_DIR21L:
 607                        /* left 21 bits of effective address */
 608                        val = lrsel(val, addend);
 609                        *loc = mask(*loc, 21) | reassemble_21(val);
 610                        break;
 611                case R_PARISC_DIR14R:
 612                        /* right 14 bits of effective address */
 613                        val = rrsel(val, addend);
 614                        *loc = mask(*loc, 14) | reassemble_14(val);
 615                        break;
 616                case R_PARISC_SEGREL32:
 617                        /* 32-bit segment relative address */
 618                        /* See note about special handling of SEGREL32 at
 619                         * the beginning of this file.
 620                         */
 621                        *loc = fsel(val, addend); 
 622                        break;
 623                case R_PARISC_DPREL21L:
 624                        /* left 21 bit of relative address */
 625                        val = lrsel(val - dp, addend);
 626                        *loc = mask(*loc, 21) | reassemble_21(val);
 627                        break;
 628                case R_PARISC_DPREL14R:
 629                        /* right 14 bit of relative address */
 630                        val = rrsel(val - dp, addend);
 631                        *loc = mask(*loc, 14) | reassemble_14(val);
 632                        break;
 633                case R_PARISC_PCREL17F:
 634                        /* 17-bit PC relative address */
 635                        /* calculate direct call offset */
 636                        val += addend;
 637                        val = (val - dot - 8)/4;
 638                        if (!RELOC_REACHABLE(val, 17)) {
 639                                /* direct distance too far, create
 640                                 * stub entry instead */
 641                                val = get_stub(me, sym->st_value, addend,
 642                                        ELF_STUB_DIRECT, loc0, targetsec);
 643                                val = (val - dot - 8)/4;
 644                                CHECK_RELOC(val, 17);
 645                        }
 646                        *loc = (*loc & ~0x1f1ffd) | reassemble_17(val);
 647                        break;
 648                case R_PARISC_PCREL22F:
 649                        /* 22-bit PC relative address; only defined for pa20 */
 650                        /* calculate direct call offset */
 651                        val += addend;
 652                        val = (val - dot - 8)/4;
 653                        if (!RELOC_REACHABLE(val, 22)) {
 654                                /* direct distance too far, create
 655                                 * stub entry instead */
 656                                val = get_stub(me, sym->st_value, addend,
 657                                        ELF_STUB_DIRECT, loc0, targetsec);
 658                                val = (val - dot - 8)/4;
 659                                CHECK_RELOC(val, 22);
 660                        }
 661                        *loc = (*loc & ~0x3ff1ffd) | reassemble_22(val);
 662                        break;
 663
 664                default:
 665                        printk(KERN_ERR "module %s: Unknown relocation: %u\n",
 666                               me->name, ELF32_R_TYPE(rel[i].r_info));
 667                        return -ENOEXEC;
 668                }
 669        }
 670
 671        return 0;
 672}
 673
 674#else
 675int apply_relocate_add(Elf_Shdr *sechdrs,
 676                       const char *strtab,
 677                       unsigned int symindex,
 678                       unsigned int relsec,
 679                       struct module *me)
 680{
 681        int i;
 682        Elf64_Rela *rel = (void *)sechdrs[relsec].sh_addr;
 683        Elf64_Sym *sym;
 684        Elf64_Word *loc;
 685        Elf64_Xword *loc64;
 686        Elf64_Addr val;
 687        Elf64_Sxword addend;
 688        Elf64_Addr dot;
 689        Elf_Addr loc0;
 690        unsigned int targetsec = sechdrs[relsec].sh_info;
 691
 692        DEBUGP("Applying relocate section %u to %u\n", relsec,
 693               targetsec);
 694        for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
 695                /* This is where to make the change */
 696                loc = (void *)sechdrs[targetsec].sh_addr
 697                      + rel[i].r_offset;
 698                /* This is the start of the target section */
 699                loc0 = sechdrs[targetsec].sh_addr;
 700                /* This is the symbol it is referring to */
 701                sym = (Elf64_Sym *)sechdrs[symindex].sh_addr
 702                        + ELF64_R_SYM(rel[i].r_info);
 703                if (!sym->st_value) {
 704                        printk(KERN_WARNING "%s: Unknown symbol %s\n",
 705                               me->name, strtab + sym->st_name);
 706                        return -ENOENT;
 707                }
 708                //dot = (sechdrs[relsec].sh_addr + rel->r_offset) & ~0x03;
 709                dot = (Elf64_Addr)loc & ~0x03;
 710                loc64 = (Elf64_Xword *)loc;
 711
 712                val = sym->st_value;
 713                addend = rel[i].r_addend;
 714
 715#if 0
 716#define r(t) ELF64_R_TYPE(rel[i].r_info)==t ? #t :
 717                printk("Symbol %s loc %p val 0x%Lx addend 0x%Lx: %s\n",
 718                        strtab + sym->st_name,
 719                        loc, val, addend,
 720                        r(R_PARISC_LTOFF14R)
 721                        r(R_PARISC_LTOFF21L)
 722                        r(R_PARISC_PCREL22F)
 723                        r(R_PARISC_DIR64)
 724                        r(R_PARISC_SEGREL32)
 725                        r(R_PARISC_FPTR64)
 726                        "UNKNOWN");
 727#undef r
 728#endif
 729
 730                switch (ELF64_R_TYPE(rel[i].r_info)) {
 731                case R_PARISC_LTOFF21L:
 732                        /* LT-relative; left 21 bits */
 733                        val = get_got(me, val, addend);
 734                        DEBUGP("LTOFF21L Symbol %s loc %p val %lx\n",
 735                               strtab + sym->st_name,
 736                               loc, val);
 737                        val = lrsel(val, 0);
 738                        *loc = mask(*loc, 21) | reassemble_21(val);
 739                        break;
 740                case R_PARISC_LTOFF14R:
 741                        /* L(ltoff(val+addend)) */
 742                        /* LT-relative; right 14 bits */
 743                        val = get_got(me, val, addend);
 744                        val = rrsel(val, 0);
 745                        DEBUGP("LTOFF14R Symbol %s loc %p val %lx\n",
 746                               strtab + sym->st_name,
 747                               loc, val);
 748                        *loc = mask(*loc, 14) | reassemble_14(val);
 749                        break;
 750                case R_PARISC_PCREL22F:
 751                        /* PC-relative; 22 bits */
 752                        DEBUGP("PCREL22F Symbol %s loc %p val %lx\n",
 753                               strtab + sym->st_name,
 754                               loc, val);
 755                        val += addend;
 756                        /* can we reach it locally? */
 757                        if (in_local(me, (void *)val)) {
 758                                /* this is the case where the symbol is local
 759                                 * to the module, but in a different section,
 760                                 * so stub the jump in case it's more than 22
 761                                 * bits away */
 762                                val = (val - dot - 8)/4;
 763                                if (!RELOC_REACHABLE(val, 22)) {
 764                                        /* direct distance too far, create
 765                                         * stub entry instead */
 766                                        val = get_stub(me, sym->st_value,
 767                                                addend, ELF_STUB_DIRECT,
 768                                                loc0, targetsec);
 769                                } else {
 770                                        /* Ok, we can reach it directly. */
 771                                        val = sym->st_value;
 772                                        val += addend;
 773                                }
 774                        } else {
 775                                val = sym->st_value;
 776                                if (strncmp(strtab + sym->st_name, "$$", 2)
 777                                    == 0)
 778                                        val = get_stub(me, val, addend, ELF_STUB_MILLI,
 779                                                       loc0, targetsec);
 780                                else
 781                                        val = get_stub(me, val, addend, ELF_STUB_GOT,
 782                                                       loc0, targetsec);
 783                        }
 784                        DEBUGP("STUB FOR %s loc %lx, val %lx+%lx at %lx\n", 
 785                               strtab + sym->st_name, loc, sym->st_value,
 786                               addend, val);
 787                        val = (val - dot - 8)/4;
 788                        CHECK_RELOC(val, 22);
 789                        *loc = (*loc & ~0x3ff1ffd) | reassemble_22(val);
 790                        break;
 791                case R_PARISC_DIR64:
 792                        /* 64-bit effective address */
 793                        *loc64 = val + addend;
 794                        break;
 795                case R_PARISC_SEGREL32:
 796                        /* 32-bit segment relative address */
 797                        /* See note about special handling of SEGREL32 at
 798                         * the beginning of this file.
 799                         */
 800                        *loc = fsel(val, addend); 
 801                        break;
 802                case R_PARISC_FPTR64:
 803                        /* 64-bit function address */
 804                        if(in_local(me, (void *)(val + addend))) {
 805                                *loc64 = get_fdesc(me, val+addend);
 806                                DEBUGP("FDESC for %s at %p points to %lx\n",
 807                                       strtab + sym->st_name, *loc64,
 808                                       ((Elf_Fdesc *)*loc64)->addr);
 809                        } else {
 810                                /* if the symbol is not local to this
 811                                 * module then val+addend is a pointer
 812                                 * to the function descriptor */
 813                                DEBUGP("Non local FPTR64 Symbol %s loc %p val %lx\n",
 814                                       strtab + sym->st_name,
 815                                       loc, val);
 816                                *loc64 = val + addend;
 817                        }
 818                        break;
 819
 820                default:
 821                        printk(KERN_ERR "module %s: Unknown relocation: %Lu\n",
 822                               me->name, ELF64_R_TYPE(rel[i].r_info));
 823                        return -ENOEXEC;
 824                }
 825        }
 826        return 0;
 827}
 828#endif
 829
 830static void
 831register_unwind_table(struct module *me,
 832                      const Elf_Shdr *sechdrs)
 833{
 834        unsigned char *table, *end;
 835        unsigned long gp;
 836
 837        if (!me->arch.unwind_section)
 838                return;
 839
 840        table = (unsigned char *)sechdrs[me->arch.unwind_section].sh_addr;
 841        end = table + sechdrs[me->arch.unwind_section].sh_size;
 842        gp = (Elf_Addr)me->module_core + me->arch.got_offset;
 843
 844        DEBUGP("register_unwind_table(), sect = %d at 0x%p - 0x%p (gp=0x%lx)\n",
 845               me->arch.unwind_section, table, end, gp);
 846        me->arch.unwind = unwind_table_add(me->name, 0, gp, table, end);
 847}
 848
 849static void
 850deregister_unwind_table(struct module *me)
 851{
 852        if (me->arch.unwind)
 853                unwind_table_remove(me->arch.unwind);
 854}
 855
 856int module_finalize(const Elf_Ehdr *hdr,
 857                    const Elf_Shdr *sechdrs,
 858                    struct module *me)
 859{
 860        int i;
 861        unsigned long nsyms;
 862        const char *strtab = NULL;
 863        Elf_Sym *newptr, *oldptr;
 864        Elf_Shdr *symhdr = NULL;
 865#ifdef DEBUG
 866        Elf_Fdesc *entry;
 867        u32 *addr;
 868
 869        entry = (Elf_Fdesc *)me->init;
 870        printk("FINALIZE, ->init FPTR is %p, GP %lx ADDR %lx\n", entry,
 871               entry->gp, entry->addr);
 872        addr = (u32 *)entry->addr;
 873        printk("INSNS: %x %x %x %x\n",
 874               addr[0], addr[1], addr[2], addr[3]);
 875        printk("got entries used %ld, gots max %ld\n"
 876               "fdescs used %ld, fdescs max %ld\n",
 877               me->arch.got_count, me->arch.got_max,
 878               me->arch.fdesc_count, me->arch.fdesc_max);
 879#endif
 880
 881        register_unwind_table(me, sechdrs);
 882
 883        /* haven't filled in me->symtab yet, so have to find it
 884         * ourselves */
 885        for (i = 1; i < hdr->e_shnum; i++) {
 886                if(sechdrs[i].sh_type == SHT_SYMTAB
 887                   && (sechdrs[i].sh_flags & SHF_ALLOC)) {
 888                        int strindex = sechdrs[i].sh_link;
 889                        /* FIXME: AWFUL HACK
 890                         * The cast is to drop the const from
 891                         * the sechdrs pointer */
 892                        symhdr = (Elf_Shdr *)&sechdrs[i];
 893                        strtab = (char *)sechdrs[strindex].sh_addr;
 894                        break;
 895                }
 896        }
 897
 898        DEBUGP("module %s: strtab %p, symhdr %p\n",
 899               me->name, strtab, symhdr);
 900
 901        if(me->arch.got_count > MAX_GOTS) {
 902                printk(KERN_ERR "%s: Global Offset Table overflow (used %ld, allowed %d)\n",
 903                                me->name, me->arch.got_count, MAX_GOTS);
 904                return -EINVAL;
 905        }
 906
 907        kfree(me->arch.section);
 908        me->arch.section = NULL;
 909
 910        /* no symbol table */
 911        if(symhdr == NULL)
 912                return 0;
 913
 914        oldptr = (void *)symhdr->sh_addr;
 915        newptr = oldptr + 1;    /* we start counting at 1 */
 916        nsyms = symhdr->sh_size / sizeof(Elf_Sym);
 917        DEBUGP("OLD num_symtab %lu\n", nsyms);
 918
 919        for (i = 1; i < nsyms; i++) {
 920                oldptr++;       /* note, count starts at 1 so preincrement */
 921                if(strncmp(strtab + oldptr->st_name,
 922                              ".L", 2) == 0)
 923                        continue;
 924
 925                if(newptr != oldptr)
 926                        *newptr++ = *oldptr;
 927                else
 928                        newptr++;
 929
 930        }
 931        nsyms = newptr - (Elf_Sym *)symhdr->sh_addr;
 932        DEBUGP("NEW num_symtab %lu\n", nsyms);
 933        symhdr->sh_size = nsyms * sizeof(Elf_Sym);
 934        return 0;
 935}
 936
 937void module_arch_cleanup(struct module *mod)
 938{
 939        deregister_unwind_table(mod);
 940}
 941