arch/ia64/kernel/module.c

   1 /*
   2  * IA-64-specific support for kernel module loader.
   3  *
   4  * Copyright (C) 2003 Hewlett-Packard Co
   5  *      David Mosberger-Tang <davidm@hpl.hp.com>
   6  *
   7  * Loosely based on patch by Rusty Russell.
   8  */
   9
  10 /* relocs tested so far:
  11
  12    DIR64LSB
  13    FPTR64LSB
  14    GPREL22
  15    LDXMOV
  16    LDXMOV
  17    LTOFF22
  18    LTOFF22X
  19    LTOFF22X
  20    LTOFF_FPTR22
  21    PCREL21B     (for br.call only; br.cond is not supported out of modules!)
  22    PCREL60B     (for brl.cond only; brl.call is not supported for modules!)
  23    PCREL64LSB
  24    SECREL32LSB
  25    SEGREL64LSB
  26  */
  27
  28
  29 #include <linux/kernel.h>
  30 #include <linux/sched.h>
  31 #include <linux/elf.h>
  32 #include <linux/moduleloader.h>
  33 #include <linux/string.h>
  34 #include <linux/vmalloc.h>
  35
  36 #include <asm/patch.h>
  37 #include <asm/unaligned.h>
  38
  39 #define ARCH_MODULE_DEBUG 0
  40
  41 #if ARCH_MODULE_DEBUG
  42 # define DEBUGP printk
  43 # define inline
  44 #else
  45 # define DEBUGP(fmt , a...)
  46 #endif
  47
  48 #ifdef CONFIG_ITANIUM
  49 # define USE_BRL        0
  50 #else
  51 # define USE_BRL        1
  52 #endif
  53
  54 #define MAX_LTOFF       ((uint64_t) (1 << 22))  /* max. allowable linkage-table offset */
  55
  56 /* Define some relocation helper macros/types: */
  57
  58 #define FORMAT_SHIFT    0
  59 #define FORMAT_BITS     3
  60 #define FORMAT_MASK     ((1 << FORMAT_BITS) - 1)
  61 #define VALUE_SHIFT     3
  62 #define VALUE_BITS      5
  63 #define VALUE_MASK      ((1 << VALUE_BITS) - 1)
  64
  65 enum reloc_target_format {
  66         /* direct encoded formats: */
  67         RF_NONE = 0,
  68         RF_INSN14 = 1,
  69         RF_INSN22 = 2,
  70         RF_INSN64 = 3,
  71         RF_32MSB = 4,
  72         RF_32LSB = 5,
  73         RF_64MSB = 6,
  74         RF_64LSB = 7,
  75
  76         /* formats that cannot be directly decoded: */
  77         RF_INSN60,
  78         RF_INSN21B,     /* imm21 form 1 */
  79         RF_INSN21M,     /* imm21 form 2 */
  80         RF_INSN21F      /* imm21 form 3 */
  81 };
  82
  83 enum reloc_value_formula {
  84         RV_DIRECT = 4,          /* S + A */
  85         RV_GPREL = 5,           /* @gprel(S + A) */
  86         RV_LTREL = 6,           /* @ltoff(S + A) */
  87         RV_PLTREL = 7,          /* @pltoff(S + A) */
  88         RV_FPTR = 8,            /* @fptr(S + A) */
  89         RV_PCREL = 9,           /* S + A - P */
  90         RV_LTREL_FPTR = 10,     /* @ltoff(@fptr(S + A)) */
  91         RV_SEGREL = 11,         /* @segrel(S + A) */
  92         RV_SECREL = 12,         /* @secrel(S + A) */
  93         RV_BDREL = 13,          /* BD + A */
  94         RV_LTV = 14,            /* S + A (like RV_DIRECT, except frozen at static link-time) */
  95         RV_PCREL2 = 15,         /* S + A - P */
  96         RV_SPECIAL = 16,        /* various (see below) */
  97         RV_RSVD17 = 17,
  98         RV_TPREL = 18,          /* @tprel(S + A) */
  99         RV_LTREL_TPREL = 19,    /* @ltoff(@tprel(S + A)) */
 100         RV_DTPMOD = 20,         /* @dtpmod(S + A) */
 101         RV_LTREL_DTPMOD = 21,   /* @ltoff(@dtpmod(S + A)) */
 102         RV_DTPREL = 22,         /* @dtprel(S + A) */
 103         RV_LTREL_DTPREL = 23,   /* @ltoff(@dtprel(S + A)) */
 104         RV_RSVD24 = 24,
 105         RV_RSVD25 = 25,
 106         RV_RSVD26 = 26,
 107         RV_RSVD27 = 27
 108         /* 28-31 reserved for implementation-specific purposes.  */
 109 };
 110
 111 #define N(reloc)        [R_IA64_##reloc] = #reloc
 112
 113 static const char *reloc_name[256] = {
 114         N(NONE),                N(IMM14),               N(IMM22),               N(IMM64),
 115         N(DIR32MSB),            N(DIR32LSB),            N(DIR64MSB),            N(DIR64LSB),
 116         N(GPREL22),             N(GPREL64I),            N(GPREL32MSB),          N(GPREL32LSB),
 117         N(GPREL64MSB),          N(GPREL64LSB),          N(LTOFF22),             N(LTOFF64I),
 118         N(PLTOFF22),            N(PLTOFF64I),           N(PLTOFF64MSB),         N(PLTOFF64LSB),
 119         N(FPTR64I),             N(FPTR32MSB),           N(FPTR32LSB),           N(FPTR64MSB),
 120         N(FPTR64LSB),           N(PCREL60B),            N(PCREL21B),            N(PCREL21M),
 121         N(PCREL21F),            N(PCREL32MSB),          N(PCREL32LSB),          N(PCREL64MSB),
 122         N(PCREL64LSB),          N(LTOFF_FPTR22),        N(LTOFF_FPTR64I),       N(LTOFF_FPTR32MSB),
 123         N(LTOFF_FPTR32LSB),     N(LTOFF_FPTR64MSB),     N(LTOFF_FPTR64LSB),     N(SEGREL32MSB),
 124         N(SEGREL32LSB),         N(SEGREL64MSB),         N(SEGREL64LSB),         N(SECREL32MSB),
 125         N(SECREL32LSB),         N(SECREL64MSB),         N(SECREL64LSB),         N(REL32MSB),
 126         N(REL32LSB),            N(REL64MSB),            N(REL64LSB),            N(LTV32MSB),
 127         N(LTV32LSB),            N(LTV64MSB),            N(LTV64LSB),            N(PCREL21BI),
 128         N(PCREL22),             N(PCREL64I),            N(IPLTMSB),             N(IPLTLSB),
 129         N(COPY),                N(LTOFF22X),            N(LDXMOV),              N(TPREL14),
 130         N(TPREL22),             N(TPREL64I),            N(TPREL64MSB),          N(TPREL64LSB),
 131         N(LTOFF_TPREL22),       N(DTPMOD64MSB),         N(DTPMOD64LSB),         N(LTOFF_DTPMOD22),
 132         N(DTPREL14),            N(DTPREL22),            N(DTPREL64I),           N(DTPREL32MSB),
 133         N(DTPREL32LSB),         N(DTPREL64MSB),         N(DTPREL64LSB),         N(LTOFF_DTPREL22)
 134 };
 135
 136 #undef N
 137
 138 /* Opaque struct for insns, to protect against derefs. */
 139 struct insn;
 140
 141 static inline uint64_t
 142 bundle (const struct insn *insn)
 143 {
 144         return (uint64_t) insn & ~0xfUL;
 145 }
 146
 147 static inline int
 148 slot (const struct insn *insn)
 149 {
 150         return (uint64_t) insn & 0x3;
 151 }
 152
 153 static int
 154 apply_imm64 (struct module *mod, struct insn *insn, uint64_t val)
 155 {
 156         if (slot(insn) != 2) {
 157                 printk(KERN_ERR "%s: invalid slot number %d for IMM64\n",
 158                        mod->name, slot(insn));
 159                 return 0;
 160         }
 161         ia64_patch_imm64((u64) insn, val);
 162         return 1;
 163 }
 164
 165 static int
 166 apply_imm60 (struct module *mod, struct insn *insn, uint64_t val)
 167 {
 168         if (slot(insn) != 2) {
 169                 printk(KERN_ERR "%s: invalid slot number %d for IMM60\n",
 170                        mod->name, slot(insn));
 171                 return 0;
 172         }
 173         if (val + ((uint64_t) 1 << 59) >= (1UL << 60)) {
 174                 printk(KERN_ERR "%s: value %ld out of IMM60 range\n",
 175                         mod->name, (long) val);
 176                 return 0;
 177         }
 178         ia64_patch_imm60((u64) insn, val);
 179         return 1;
 180 }
 181
 182 static int
 183 apply_imm22 (struct module *mod, struct insn *insn, uint64_t val)
 184 {
 185         if (val + (1 << 21) >= (1 << 22)) {
 186                 printk(KERN_ERR "%s: value %li out of IMM22 range\n",
 187                         mod->name, (long)val);
 188                 return 0;
 189         }
 190         ia64_patch((u64) insn, 0x01fffcfe000UL, (  ((val & 0x200000UL) << 15) /* bit 21 -> 36 */
 191                                                  | ((val & 0x1f0000UL) <<  6) /* bit 16 -> 22 */
 192                                                  | ((val & 0x00ff80UL) << 20) /* bit  7 -> 27 */
 193                                                  | ((val & 0x00007fUL) << 13) /* bit  0 -> 13 */));
 194         return 1;
 195 }
 196
 197 static int
 198 apply_imm21b (struct module *mod, struct insn *insn, uint64_t val)
 199 {
 200         if (val + (1 << 20) >= (1 << 21)) {
 201                 printk(KERN_ERR "%s: value %li out of IMM21b range\n",
 202                         mod->name, (long)val);
 203                 return 0;
 204         }
 205         ia64_patch((u64) insn, 0x11ffffe000UL, (  ((val & 0x100000UL) << 16) /* bit 20 -> 36 */
 206                                                 | ((val & 0x0fffffUL) << 13) /* bit  0 -> 13 */));
 207         return 1;
 208 }
 209
 210 #if USE_BRL
 211
 212 struct plt_entry {
 213         /* Three instruction bundles in PLT. */
 214         unsigned char bundle[2][16];
 215 };
 216
 217 static const struct plt_entry ia64_plt_template = {
 218         {
 219                 {
 220                         0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
 221                         0x00, 0x00, 0x00, 0x00, 0x00, 0x20, /*       movl gp=TARGET_GP */
 222                         0x00, 0x00, 0x00, 0x60
 223                 },
 224                 {
 225                         0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
 226                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /*       brl.many gp=TARGET_GP */
 227                         0x08, 0x00, 0x00, 0xc0
 228                 }
 229         }
 230 };
 231
 232 static int
 233 patch_plt (struct module *mod, struct plt_entry *plt, long target_ip, unsigned long target_gp)
 234 {
 235         if (apply_imm64(mod, (struct insn *) (plt->bundle[0] + 2), target_gp)
 236             && apply_imm60(mod, (struct insn *) (plt->bundle[1] + 2),
 237                            (target_ip - (int64_t) plt->bundle[1]) / 16))
 238                 return 1;
 239         return 0;
 240 }
 241
 242 unsigned long
 243 plt_target (struct plt_entry *plt)
 244 {
 245         uint64_t b0, b1, *b = (uint64_t *) plt->bundle[1];
 246         long off;
 247
 248         b0 = b[0]; b1 = b[1];
 249         off = (  ((b1 & 0x00fffff000000000UL) >> 36)            /* imm20b -> bit 0 */
 250                | ((b0 >> 48) << 20) | ((b1 & 0x7fffffUL) << 36) /* imm39 -> bit 20 */
 251                | ((b1 & 0x0800000000000000UL) << 0));           /* i -> bit 59 */
 252         return (long) plt->bundle[1] + 16*off;
 253 }
 254
 255 #else /* !USE_BRL */
 256
 257 struct plt_entry {
 258         /* Three instruction bundles in PLT. */
 259         unsigned char bundle[3][16];
 260 };
 261
 262 static const struct plt_entry ia64_plt_template = {
 263         {
 264                 {
 265                         0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
 266                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /*       movl r16=TARGET_IP */
 267                         0x02, 0x00, 0x00, 0x60
 268                 },
 269                 {
 270                         0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
 271                         0x00, 0x00, 0x00, 0x00, 0x00, 0x20, /*       movl gp=TARGET_GP */
 272                         0x00, 0x00, 0x00, 0x60
 273                 },
 274                 {
 275                         0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
 276                         0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /*       mov b6=r16 */
 277                         0x60, 0x00, 0x80, 0x00              /*       br.few b6 */
 278                 }
 279         }
 280 };
 281
 282 static int
 283 patch_plt (struct module *mod, struct plt_entry *plt, long target_ip, unsigned long target_gp)
 284 {
 285         if (apply_imm64(mod, (struct insn *) (plt->bundle[0] + 2), target_ip)
 286             && apply_imm64(mod, (struct insn *) (plt->bundle[1] + 2), target_gp))
 287                 return 1;
 288         return 0;
 289 }
 290
 291 unsigned long
 292 plt_target (struct plt_entry *plt)
 293 {
 294         uint64_t b0, b1, *b = (uint64_t *) plt->bundle[0];
 295
 296         b0 = b[0]; b1 = b[1];
 297         return (  ((b1 & 0x000007f000000000) >> 36)             /* imm7b -> bit 0 */
 298                 | ((b1 & 0x07fc000000000000) >> 43)             /* imm9d -> bit 7 */
 299                 | ((b1 & 0x0003e00000000000) >> 29)             /* imm5c -> bit 16 */
 300                 | ((b1 & 0x0000100000000000) >> 23)             /* ic -> bit 21 */
 301                 | ((b0 >> 46) << 22) | ((b1 & 0x7fffff) << 40)  /* imm41 -> bit 22 */
 302                 | ((b1 & 0x0800000000000000) <<  4));           /* i -> bit 63 */
 303 }
 304
 305 #endif /* !USE_BRL */
 306
 307 void
 308 module_free (struct module *mod, void *module_region)
 309 {
 310         if (mod && mod->arch.init_unw_table &&
 311             module_region == mod->module_init) {
 312                 unw_remove_unwind_table(mod->arch.init_unw_table);
 313                 mod->arch.init_unw_table = NULL;
 314         }
 315         vfree(module_region);
 316 }
 317
 318 /* Have we already seen one of these relocations? */
 319 /* FIXME: we could look in other sections, too --RR */
 320 static int
 321 duplicate_reloc (const Elf64_Rela *rela, unsigned int num)
 322 {
 323         unsigned int i;
 324
 325         for (i = 0; i < num; i++) {
 326                 if (rela[i].r_info == rela[num].r_info && rela[i].r_addend == rela[num].r_addend)
 327                         return 1;
 328         }
 329         return 0;
 330 }
 331
 332 /* Count how many GOT entries we may need */
 333 static unsigned int
 334 count_gots (const Elf64_Rela *rela, unsigned int num)
 335 {
 336         unsigned int i, ret = 0;
 337
 338         /* Sure, this is order(n^2), but it's usually short, and not
 339            time critical */
 340         for (i = 0; i < num; i++) {
 341                 switch (ELF64_R_TYPE(rela[i].r_info)) {
 342                       case R_IA64_LTOFF22:
 343                       case R_IA64_LTOFF22X:
 344                       case R_IA64_LTOFF64I:
 345                       case R_IA64_LTOFF_FPTR22:
 346                       case R_IA64_LTOFF_FPTR64I:
 347                       case R_IA64_LTOFF_FPTR32MSB:
 348                       case R_IA64_LTOFF_FPTR32LSB:
 349                       case R_IA64_LTOFF_FPTR64MSB:
 350                       case R_IA64_LTOFF_FPTR64LSB:
 351                         if (!duplicate_reloc(rela, i))
 352                                 ret++;
 353                         break;
 354                 }
 355         }
 356         return ret;
 357 }
 358
 359 /* Count how many PLT entries we may need */
 360 static unsigned int
 361 count_plts (const Elf64_Rela *rela, unsigned int num)
 362 {
 363         unsigned int i, ret = 0;
 364
 365         /* Sure, this is order(n^2), but it's usually short, and not
 366            time critical */
 367         for (i = 0; i < num; i++) {
 368                 switch (ELF64_R_TYPE(rela[i].r_info)) {
 369                       case R_IA64_PCREL21B:
 370                       case R_IA64_PLTOFF22:
 371                       case R_IA64_PLTOFF64I:
 372                       case R_IA64_PLTOFF64MSB:
 373                       case R_IA64_PLTOFF64LSB:
 374                       case R_IA64_IPLTMSB:
 375                       case R_IA64_IPLTLSB:
 376                         if (!duplicate_reloc(rela, i))
 377                                 ret++;
 378                         break;
 379                 }
 380         }
 381         return ret;
 382 }
 383
 384 /* We need to create an function-descriptors for any internal function
 385    which is referenced. */
 386 static unsigned int
 387 count_fdescs (const Elf64_Rela *rela, unsigned int num)
 388 {
 389         unsigned int i, ret = 0;
 390
 391         /* Sure, this is order(n^2), but it's usually short, and not time critical.  */
 392         for (i = 0; i < num; i++) {
 393                 switch (ELF64_R_TYPE(rela[i].r_info)) {
 394                       case R_IA64_FPTR64I:
 395                       case R_IA64_FPTR32LSB:
 396                       case R_IA64_FPTR32MSB:
 397                       case R_IA64_FPTR64LSB:
 398                       case R_IA64_FPTR64MSB:
 399                       case R_IA64_LTOFF_FPTR22:
 400                       case R_IA64_LTOFF_FPTR32LSB:
 401                       case R_IA64_LTOFF_FPTR32MSB:
 402                       case R_IA64_LTOFF_FPTR64I:
 403                       case R_IA64_LTOFF_FPTR64LSB:
 404                       case R_IA64_LTOFF_FPTR64MSB:
 405                       case R_IA64_IPLTMSB:
 406                       case R_IA64_IPLTLSB:
 407                         /*
 408                          * Jumps to static functions sometimes go straight to their
 409                          * offset.  Of course, that may not be possible if the jump is
 410                          * from init -> core or vice. versa, so we need to generate an
 411                          * FDESC (and PLT etc) for that.
 412                          */
 413                       case R_IA64_PCREL21B:
 414                         if (!duplicate_reloc(rela, i))
 415                                 ret++;
 416                         break;
 417                 }
 418         }
 419         return ret;
 420 }
 421
 422 int
 423 module_frob_arch_sections (Elf_Ehdr *ehdr, Elf_Shdr *sechdrs, char *secstrings,
 424                            struct module *mod)
 425 {
 426         unsigned long core_plts = 0, init_plts = 0, gots = 0, fdescs = 0;
 427         Elf64_Shdr *s, *sechdrs_end = sechdrs + ehdr->e_shnum;
 428
 429         /*
 430          * To store the PLTs and function-descriptors, we expand the .text section for
 431          * core module-code and the .init.text section for initialization code.
 432          */
 433         for (s = sechdrs; s < sechdrs_end; ++s)
 434                 if (strcmp(".core.plt", secstrings + s->sh_name) == 0)
 435                         mod->arch.core_plt = s;
 436                 else if (strcmp(".init.plt", secstrings + s->sh_name) == 0)
 437                         mod->arch.init_plt = s;
 438                 else if (strcmp(".got", secstrings + s->sh_name) == 0)
 439                         mod->arch.got = s;
 440                 else if (strcmp(".opd", secstrings + s->sh_name) == 0)
 441                         mod->arch.opd = s;
 442                 else if (strcmp(".IA_64.unwind", secstrings + s->sh_name) == 0)
 443                         mod->arch.unwind = s;
 444 #ifdef CONFIG_PARAVIRT
 445                 else if (strcmp(".paravirt_bundles",
 446                                 secstrings + s->sh_name) == 0)
 447                         mod->arch.paravirt_bundles = s;
 448                 else if (strcmp(".paravirt_insts",
 449                                 secstrings + s->sh_name) == 0)
 450                         mod->arch.paravirt_insts = s;
 451 #endif
 452
 453         if (!mod->arch.core_plt || !mod->arch.init_plt || !mod->arch.got || !mod->arch.opd) {
 454                 printk(KERN_ERR "%s: sections missing\n", mod->name);
 455                 return -ENOEXEC;
 456         }
 457
 458         /* GOT and PLTs can occur in any relocated section... */
 459         for (s = sechdrs + 1; s < sechdrs_end; ++s) {
 460                 const Elf64_Rela *rels = (void *)ehdr + s->sh_offset;
 461                 unsigned long numrels = s->sh_size/sizeof(Elf64_Rela);
 462
 463                 if (s->sh_type != SHT_RELA)
 464                         continue;
 465
 466                 gots += count_gots(rels, numrels);
 467                 fdescs += count_fdescs(rels, numrels);
 468                 if (strstr(secstrings + s->sh_name, ".init"))
 469                         init_plts += count_plts(rels, numrels);
 470                 else
 471                         core_plts += count_plts(rels, numrels);
 472         }
 473
 474         mod->arch.core_plt->sh_type = SHT_NOBITS;
 475         mod->arch.core_plt->sh_flags = SHF_EXECINSTR | SHF_ALLOC;
 476         mod->arch.core_plt->sh_addralign = 16;
 477         mod->arch.core_plt->sh_size = core_plts * sizeof(struct plt_entry);
 478         mod->arch.init_plt->sh_type = SHT_NOBITS;
 479         mod->arch.init_plt->sh_flags = SHF_EXECINSTR | SHF_ALLOC;
 480         mod->arch.init_plt->sh_addralign = 16;
 481         mod->arch.init_plt->sh_size = init_plts * sizeof(struct plt_entry);
 482         mod->arch.got->sh_type = SHT_NOBITS;
 483         mod->arch.got->sh_flags = ARCH_SHF_SMALL | SHF_ALLOC;
 484         mod->arch.got->sh_addralign = 8;
 485         mod->arch.got->sh_size = gots * sizeof(struct got_entry);
 486         mod->arch.opd->sh_type = SHT_NOBITS;
 487         mod->arch.opd->sh_flags = SHF_ALLOC;
 488         mod->arch.opd->sh_addralign = 8;
 489         mod->arch.opd->sh_size = fdescs * sizeof(struct fdesc);
 490         DEBUGP("%s: core.plt=%lx, init.plt=%lx, got=%lx, fdesc=%lx\n",
 491                __func__, mod->arch.core_plt->sh_size, mod->arch.init_plt->sh_size,
 492                mod->arch.got->sh_size, mod->arch.opd->sh_size);
 493         return 0;
 494 }
 495
 496 static inline int
 497 in_init (const struct module *mod, uint64_t addr)
 498 {
 499         return addr - (uint64_t) mod->module_init < mod->init_size;
 500 }
 501
 502 static inline int
 503 in_core (const struct module *mod, uint64_t addr)
 504 {
 505         return addr - (uint64_t) mod->module_core < mod->core_size;
 506 }
 507
 508 static inline int
 509 is_internal (const struct module *mod, uint64_t value)
 510 {
 511         return in_init(mod, value) || in_core(mod, value);
 512 }
 513
 514 /*
 515  * Get gp-relative offset for the linkage-table entry of VALUE.
 516  */
 517 static uint64_t
 518 get_ltoff (struct module *mod, uint64_t value, int *okp)
 519 {
 520         struct got_entry *got, *e;
 521
 522         if (!*okp)
 523                 return 0;
 524
 525         got = (void *) mod->arch.got->sh_addr;
 526         for (e = got; e < got + mod->arch.next_got_entry; ++e)
 527                 if (e->val == value)
 528                         goto found;
 529
 530         /* Not enough GOT entries? */
 531         BUG_ON(e >= (struct got_entry *) (mod->arch.got->sh_addr + mod->arch.got->sh_size));
 532
 533         e->val = value;
 534         ++mod->arch.next_got_entry;
 535   found:
 536         return (uint64_t) e - mod->arch.gp;
 537 }
 538
 539 static inline int
 540 gp_addressable (struct module *mod, uint64_t value)
 541 {
 542         return value - mod->arch.gp + MAX_LTOFF/2 < MAX_LTOFF;
 543 }
 544
 545 /* Get PC-relative PLT entry for this value.  Returns 0 on failure. */
 546 static uint64_t
 547 get_plt (struct module *mod, const struct insn *insn, uint64_t value, int *okp)
 548 {
 549         struct plt_entry *plt, *plt_end;
 550         uint64_t target_ip, target_gp;
 551
 552         if (!*okp)
 553                 return 0;
 554
 555         if (in_init(mod, (uint64_t) insn)) {
 556                 plt = (void *) mod->arch.init_plt->sh_addr;
 557                 plt_end = (void *) plt + mod->arch.init_plt->sh_size;
 558         } else {
 559                 plt = (void *) mod->arch.core_plt->sh_addr;
 560                 plt_end = (void *) plt + mod->arch.core_plt->sh_size;
 561         }
 562
 563         /* "value" is a pointer to a function-descriptor; fetch the target ip/gp from it: */
 564         target_ip = ((uint64_t *) value)[0];
 565         target_gp = ((uint64_t *) value)[1];
 566
 567         /* Look for existing PLT entry. */
 568         while (plt->bundle[0][0]) {
 569                 if (plt_target(plt) == target_ip)
 570                         goto found;
 571                 if (++plt >= plt_end)
 572                         BUG();
 573         }
 574         *plt = ia64_plt_template;
 575         if (!patch_plt(mod, plt, target_ip, target_gp)) {
 576                 *okp = 0;
 577                 return 0;
 578         }
 579 #if ARCH_MODULE_DEBUG
 580         if (plt_target(plt) != target_ip) {
 581                 printk("%s: mistargeted PLT: wanted %lx, got %lx\n",
 582                        __func__, target_ip, plt_target(plt));
 583                 *okp = 0;
 584                 return 0;
 585         }
 586 #endif
 587   found:
 588         return (uint64_t) plt;
 589 }
 590
 591 /* Get function descriptor for VALUE. */
 592 static uint64_t
 593 get_fdesc (struct module *mod, uint64_t value, int *okp)
 594 {
 595         struct fdesc *fdesc = (void *) mod->arch.opd->sh_addr;
 596
 597         if (!*okp)
 598                 return 0;
 599
 600         if (!value) {
 601                 printk(KERN_ERR "%s: fdesc for zero requested!\n", mod->name);
 602                 return 0;
 603         }
 604
 605         if (!is_internal(mod, value))
 606                 /*
 607                  * If it's not a module-local entry-point, "value" already points to a
 608                  * function-descriptor.
 609                  */
 610                 return value;
 611
 612         /* Look for existing function descriptor. */
 613         while (fdesc->ip) {
 614                 if (fdesc->ip == value)
 615                         return (uint64_t)fdesc;
 616                 if ((uint64_t) ++fdesc >= mod->arch.opd->sh_addr + mod->arch.opd->sh_size)
 617                         BUG();
 618         }
 619
 620         /* Create new one */
 621         fdesc->ip = value;
 622         fdesc->gp = mod->arch.gp;
 623         return (uint64_t) fdesc;
 624 }
 625
 626 static inline int
 627 do_reloc (struct module *mod, uint8_t r_type, Elf64_Sym *sym, uint64_t addend,
 628           Elf64_Shdr *sec, void *location)
 629 {
 630         enum reloc_target_format format = (r_type >> FORMAT_SHIFT) & FORMAT_MASK;
 631         enum reloc_value_formula formula = (r_type >> VALUE_SHIFT) & VALUE_MASK;
 632         uint64_t val;
 633         int ok = 1;
 634
 635         val = sym->st_value + addend;
 636
 637         switch (formula) {
 638               case RV_SEGREL:   /* segment base is arbitrarily chosen to be 0 for kernel modules */
 639               case RV_DIRECT:
 640                 break;
 641
 642               case RV_GPREL:      val -= mod->arch.gp; break;
 643               case RV_LTREL:      val = get_ltoff(mod, val, &ok); break;
 644               case RV_PLTREL:     val = get_plt(mod, location, val, &ok); break;
 645               case RV_FPTR:       val = get_fdesc(mod, val, &ok); break;
 646               case RV_SECREL:     val -= sec->sh_addr; break;
 647               case RV_LTREL_FPTR: val = get_ltoff(mod, get_fdesc(mod, val, &ok), &ok); break;
 648
 649               case RV_PCREL:
 650                 switch (r_type) {
 651                       case R_IA64_PCREL21B:
 652                         if ((in_init(mod, val) && in_core(mod, (uint64_t)location)) ||
 653                             (in_core(mod, val) && in_init(mod, (uint64_t)location))) {
 654                                 /*
 655                                  * Init section may have been allocated far away from core,
 656                                  * if the branch won't reach, then allocate a plt for it.
 657                                  */
 658                                 uint64_t delta = ((int64_t)val - (int64_t)location) / 16;
 659                                 if (delta + (1 << 20) >= (1 << 21)) {
 660                                         val = get_fdesc(mod, val, &ok);
 661                                         val = get_plt(mod, location, val, &ok);
 662                                 }
 663                         } else if (!is_internal(mod, val))
 664                                 val = get_plt(mod, location, val, &ok);
 665                         /* FALL THROUGH */
 666                       default:
 667                         val -= bundle(location);
 668                         break;
 669
 670                       case R_IA64_PCREL32MSB:
 671                       case R_IA64_PCREL32LSB:
 672                       case R_IA64_PCREL64MSB:
 673                       case R_IA64_PCREL64LSB:
 674                         val -= (uint64_t) location;
 675                         break;
 676
 677                 }
 678                 switch (r_type) {
 679                       case R_IA64_PCREL60B: format = RF_INSN60; break;
 680                       case R_IA64_PCREL21B: format = RF_INSN21B; break;
 681                       case R_IA64_PCREL21M: format = RF_INSN21M; break;
 682                       case R_IA64_PCREL21F: format = RF_INSN21F; break;
 683                       default: break;
 684                 }
 685                 break;
 686
 687               case RV_BDREL:
 688                 val -= (uint64_t) (in_init(mod, val) ? mod->module_init : mod->module_core);
 689                 break;
 690
 691               case RV_LTV:
 692                 /* can link-time value relocs happen here?  */
 693                 BUG();
 694                 break;
 695
 696               case RV_PCREL2:
 697                 if (r_type == R_IA64_PCREL21BI) {
 698                         if (!is_internal(mod, val)) {
 699                                 printk(KERN_ERR "%s: %s reloc against "
 700                                         "non-local symbol (%lx)\n", __func__,
 701                                         reloc_name[r_type], (unsigned long)val);
 702                                 return -ENOEXEC;
 703                         }
 704                         format = RF_INSN21B;
 705                 }
 706                 val -= bundle(location);
 707                 break;
 708
 709               case RV_SPECIAL:
 710                 switch (r_type) {
 711                       case R_IA64_IPLTMSB:
 712                       case R_IA64_IPLTLSB:
 713                         val = get_fdesc(mod, get_plt(mod, location, val, &ok), &ok);
 714                         format = RF_64LSB;
 715                         if (r_type == R_IA64_IPLTMSB)
 716                                 format = RF_64MSB;
 717                         break;
 718
 719                       case R_IA64_SUB:
 720                         val = addend - sym->st_value;
 721                         format = RF_INSN64;
 722                         break;
 723
 724                       case R_IA64_LTOFF22X:
 725                         if (gp_addressable(mod, val))
 726                                 val -= mod->arch.gp;
 727                         else
 728                                 val = get_ltoff(mod, val, &ok);
 729                         format = RF_INSN22;
 730                         break;
 731
 732                       case R_IA64_LDXMOV:
 733                         if (gp_addressable(mod, val)) {
 734                                 /* turn "ld8" into "mov": */
 735                                 DEBUGP("%s: patching ld8 at %p to mov\n", __func__, location);
 736                                 ia64_patch((u64) location, 0x1fff80fe000UL, 0x10000000000UL);
 737                         }
 738                         return 0;
 739
 740                       default:
 741                         if (reloc_name[r_type])
 742                                 printk(KERN_ERR "%s: special reloc %s not supported",
 743                                        mod->name, reloc_name[r_type]);
 744                         else
 745                                 printk(KERN_ERR "%s: unknown special reloc %x\n",
 746                                        mod->name, r_type);
 747                         return -ENOEXEC;
 748                 }
 749                 break;
 750
 751               case RV_TPREL:
 752               case RV_LTREL_TPREL:
 753               case RV_DTPMOD:
 754               case RV_LTREL_DTPMOD:
 755               case RV_DTPREL:
 756               case RV_LTREL_DTPREL:
 757                 printk(KERN_ERR "%s: %s reloc not supported\n",
 758                        mod->name, reloc_name[r_type] ? reloc_name[r_type] : "?");
 759                 return -ENOEXEC;
 760
 761               default:
 762                 printk(KERN_ERR "%s: unknown reloc %x\n", mod->name, r_type);
 763                 return -ENOEXEC;
 764         }
 765
 766         if (!ok)
 767                 return -ENOEXEC;
 768
 769         DEBUGP("%s: [%p]<-%016lx = %s(%lx)\n", __func__, location, val,
 770                reloc_name[r_type] ? reloc_name[r_type] : "?", sym->st_value + addend);
 771
 772         switch (format) {
 773               case RF_INSN21B:  ok = apply_imm21b(mod, location, (int64_t) val / 16); break;
 774               case RF_INSN22:   ok = apply_imm22(mod, location, val); break;
 775               case RF_INSN64:   ok = apply_imm64(mod, location, val); break;
 776               case RF_INSN60:   ok = apply_imm60(mod, location, (int64_t) val / 16); break;
 777               case RF_32LSB:    put_unaligned(val, (uint32_t *) location); break;
 778               case RF_64LSB:    put_unaligned(val, (uint64_t *) location); break;
 779               case RF_32MSB:    /* ia64 Linux is little-endian... */
 780               case RF_64MSB:    /* ia64 Linux is little-endian... */
 781               case RF_INSN14:   /* must be within-module, i.e., resolved by "ld -r" */
 782               case RF_INSN21M:  /* must be within-module, i.e., resolved by "ld -r" */
 783               case RF_INSN21F:  /* must be within-module, i.e., resolved by "ld -r" */
 784                 printk(KERN_ERR "%s: format %u needed by %s reloc is not supported\n",
 785                        mod->name, format, reloc_name[r_type] ? reloc_name[r_type] : "?");
 786                 return -ENOEXEC;
 787
 788               default:
 789                 printk(KERN_ERR "%s: relocation %s resulted in unknown format %u\n",
 790                        mod->name, reloc_name[r_type] ? reloc_name[r_type] : "?", format);
 791                 return -ENOEXEC;
 792         }
 793         return ok ? 0 : -ENOEXEC;
 794 }
 795
 796 int
 797 apply_relocate_add (Elf64_Shdr *sechdrs, const char *strtab, unsigned int symindex,
 798                     unsigned int relsec, struct module *mod)
 799 {
 800         unsigned int i, n = sechdrs[relsec].sh_size / sizeof(Elf64_Rela);
 801         Elf64_Rela *rela = (void *) sechdrs[relsec].sh_addr;
 802         Elf64_Shdr *target_sec;
 803         int ret;
 804
 805         DEBUGP("%s: applying section %u (%u relocs) to %u\n", __func__,
 806                relsec, n, sechdrs[relsec].sh_info);
 807
 808         target_sec = sechdrs + sechdrs[relsec].sh_info;
 809
 810         if (target_sec->sh_entsize == ~0UL)
 811                 /*
 812                  * If target section wasn't allocated, we don't need to relocate it.
 813                  * Happens, e.g., for debug sections.
 814                  */
 815                 return 0;
 816
 817         if (!mod->arch.gp) {
 818                 /*
 819                  * XXX Should have an arch-hook for running this after final section
 820                  *     addresses have been selected...
 821                  */
 822                 uint64_t gp;
 823                 if (mod->core_size > MAX_LTOFF)
 824                         /*
 825                          * This takes advantage of fact that SHF_ARCH_SMALL gets allocated
 826                          * at the end of the module.
 827                          */
 828                         gp = mod->core_size - MAX_LTOFF / 2;
 829                 else
 830                         gp = mod->core_size / 2;
 831                 gp = (uint64_t) mod->module_core + ((gp + 7) & -8);
 832                 mod->arch.gp = gp;
 833                 DEBUGP("%s: placing gp at 0x%lx\n", __func__, gp);
 834         }
 835
 836         for (i = 0; i < n; i++) {
 837                 ret = do_reloc(mod, ELF64_R_TYPE(rela[i].r_info),
 838                                ((Elf64_Sym *) sechdrs[symindex].sh_addr
 839                                 + ELF64_R_SYM(rela[i].r_info)),
 840                                rela[i].r_addend, target_sec,
 841                                (void *) target_sec->sh_addr + rela[i].r_offset);
 842                 if (ret < 0)
 843                         return ret;
 844         }
 845         return 0;
 846 }
 847
 848 /*
 849  * Modules contain a single unwind table which covers both the core and the init text
 850  * sections but since the two are not contiguous, we need to split this table up such that
 851  * we can register (and unregister) each "segment" separately.  Fortunately, this sounds
 852  * more complicated than it really is.
 853  */
 854 static void
 855 register_unwind_table (struct module *mod)
 856 {
 857         struct unw_table_entry *start = (void *) mod->arch.unwind->sh_addr;
 858         struct unw_table_entry *end = start + mod->arch.unwind->sh_size / sizeof (*start);
 859         struct unw_table_entry tmp, *e1, *e2, *core, *init;
 860         unsigned long num_init = 0, num_core = 0;
 861
 862         /* First, count how many init and core unwind-table entries there are.  */
 863         for (e1 = start; e1 < end; ++e1)
 864                 if (in_init(mod, e1->start_offset))
 865                         ++num_init;
 866                 else
 867                         ++num_core;
 868         /*
 869          * Second, sort the table such that all unwind-table entries for the init and core
 870          * text sections are nicely separated.  We do this with a stupid bubble sort
 871          * (unwind tables don't get ridiculously huge).
 872          */
 873         for (e1 = start; e1 < end; ++e1) {
 874                 for (e2 = e1 + 1; e2 < end; ++e2) {
 875                         if (e2->start_offset < e1->start_offset) {
 876                                 tmp = *e1;
 877                                 *e1 = *e2;
 878                                 *e2 = tmp;
 879                         }
 880                 }
 881         }
 882         /*
 883          * Third, locate the init and core segments in the unwind table:
 884          */
 885         if (in_init(mod, start->start_offset)) {
 886                 init = start;
 887                 core = start + num_init;
 888         } else {
 889                 core = start;
 890                 init = start + num_core;
 891         }
 892
 893         DEBUGP("%s: name=%s, gp=%lx, num_init=%lu, num_core=%lu\n", __func__,
 894                mod->name, mod->arch.gp, num_init, num_core);
 895
 896         /*
 897          * Fourth, register both tables (if not empty).
 898          */
 899         if (num_core > 0) {
 900                 mod->arch.core_unw_table = unw_add_unwind_table(mod->name, 0, mod->arch.gp,
 901                                                                 core, core + num_core);
 902                 DEBUGP("%s:  core: handle=%p [%p-%p)\n", __func__,
 903                        mod->arch.core_unw_table, core, core + num_core);
 904         }
 905         if (num_init > 0) {
 906                 mod->arch.init_unw_table = unw_add_unwind_table(mod->name, 0, mod->arch.gp,
 907                                                                 init, init + num_init);
 908                 DEBUGP("%s:  init: handle=%p [%p-%p)\n", __func__,
 909                        mod->arch.init_unw_table, init, init + num_init);
 910         }
 911 }
 912
 913 int
 914 module_finalize (const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs, struct module *mod)
 915 {
 916         DEBUGP("%s: init: entry=%p\n", __func__, mod->init);
 917         if (mod->arch.unwind)
 918                 register_unwind_table(mod);
 919 #ifdef CONFIG_PARAVIRT
 920         if (mod->arch.paravirt_bundles) {
 921                 struct paravirt_patch_site_bundle *start =
 922                         (struct paravirt_patch_site_bundle *)
 923                         mod->arch.paravirt_bundles->sh_addr;
 924                 struct paravirt_patch_site_bundle *end =
 925                         (struct paravirt_patch_site_bundle *)
 926                         (mod->arch.paravirt_bundles->sh_addr +
 927                          mod->arch.paravirt_bundles->sh_size);
 928
 929                 paravirt_patch_apply_bundle(start, end);
 930         }
 931         if (mod->arch.paravirt_insts) {
 932                 struct paravirt_patch_site_inst *start =
 933                         (struct paravirt_patch_site_inst *)
 934                         mod->arch.paravirt_insts->sh_addr;
 935                 struct paravirt_patch_site_inst *end =
 936                         (struct paravirt_patch_site_inst *)
 937                         (mod->arch.paravirt_insts->sh_addr +
 938                          mod->arch.paravirt_insts->sh_size);
 939
 940                 paravirt_patch_apply_inst(start, end);
 941         }
 942 #endif
 943         return 0;
 944 }
 945
 946 void
 947 module_arch_cleanup (struct module *mod)
 948 {
 949         if (mod->arch.init_unw_table)
 950                 unw_remove_unwind_table(mod->arch.init_unw_table);
 951         if (mod->arch.core_unw_table)
 952                 unw_remove_unwind_table(mod->arch.core_unw_table);
 953 }