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_alloc (unsigned long size)
 309 {
 310         if (!size)
 311                 return NULL;
 312         return vmalloc(size);
 313 }
 314
 315 void
 316 module_free (struct module *mod, void *module_region)
 317 {
 318         if (mod && mod->arch.init_unw_table &&
 319             module_region == mod->module_init) {
 320                 unw_remove_unwind_table(mod->arch.init_unw_table);
 321                 mod->arch.init_unw_table = NULL;
 322         }
 323         vfree(module_region);
 324 }
 325
 326 /* Have we already seen one of these relocations? */
 327 /* FIXME: we could look in other sections, too --RR */
 328 static int
 329 duplicate_reloc (const Elf64_Rela *rela, unsigned int num)
 330 {
 331         unsigned int i;
 332
 333         for (i = 0; i < num; i++) {
 334                 if (rela[i].r_info == rela[num].r_info && rela[i].r_addend == rela[num].r_addend)
 335                         return 1;
 336         }
 337         return 0;
 338 }
 339
 340 /* Count how many GOT entries we may need */
 341 static unsigned int
 342 count_gots (const Elf64_Rela *rela, unsigned int num)
 343 {
 344         unsigned int i, ret = 0;
 345
 346         /* Sure, this is order(n^2), but it's usually short, and not
 347            time critical */
 348         for (i = 0; i < num; i++) {
 349                 switch (ELF64_R_TYPE(rela[i].r_info)) {
 350                       case R_IA64_LTOFF22:
 351                       case R_IA64_LTOFF22X:
 352                       case R_IA64_LTOFF64I:
 353                       case R_IA64_LTOFF_FPTR22:
 354                       case R_IA64_LTOFF_FPTR64I:
 355                       case R_IA64_LTOFF_FPTR32MSB:
 356                       case R_IA64_LTOFF_FPTR32LSB:
 357                       case R_IA64_LTOFF_FPTR64MSB:
 358                       case R_IA64_LTOFF_FPTR64LSB:
 359                         if (!duplicate_reloc(rela, i))
 360                                 ret++;
 361                         break;
 362                 }
 363         }
 364         return ret;
 365 }
 366
 367 /* Count how many PLT entries we may need */
 368 static unsigned int
 369 count_plts (const Elf64_Rela *rela, unsigned int num)
 370 {
 371         unsigned int i, ret = 0;
 372
 373         /* Sure, this is order(n^2), but it's usually short, and not
 374            time critical */
 375         for (i = 0; i < num; i++) {
 376                 switch (ELF64_R_TYPE(rela[i].r_info)) {
 377                       case R_IA64_PCREL21B:
 378                       case R_IA64_PLTOFF22:
 379                       case R_IA64_PLTOFF64I:
 380                       case R_IA64_PLTOFF64MSB:
 381                       case R_IA64_PLTOFF64LSB:
 382                       case R_IA64_IPLTMSB:
 383                       case R_IA64_IPLTLSB:
 384                         if (!duplicate_reloc(rela, i))
 385                                 ret++;
 386                         break;
 387                 }
 388         }
 389         return ret;
 390 }
 391
 392 /* We need to create an function-descriptors for any internal function
 393    which is referenced. */
 394 static unsigned int
 395 count_fdescs (const Elf64_Rela *rela, unsigned int num)
 396 {
 397         unsigned int i, ret = 0;
 398
 399         /* Sure, this is order(n^2), but it's usually short, and not time critical.  */
 400         for (i = 0; i < num; i++) {
 401                 switch (ELF64_R_TYPE(rela[i].r_info)) {
 402                       case R_IA64_FPTR64I:
 403                       case R_IA64_FPTR32LSB:
 404                       case R_IA64_FPTR32MSB:
 405                       case R_IA64_FPTR64LSB:
 406                       case R_IA64_FPTR64MSB:
 407                       case R_IA64_LTOFF_FPTR22:
 408                       case R_IA64_LTOFF_FPTR32LSB:
 409                       case R_IA64_LTOFF_FPTR32MSB:
 410                       case R_IA64_LTOFF_FPTR64I:
 411                       case R_IA64_LTOFF_FPTR64LSB:
 412                       case R_IA64_LTOFF_FPTR64MSB:
 413                       case R_IA64_IPLTMSB:
 414                       case R_IA64_IPLTLSB:
 415                         /*
 416                          * Jumps to static functions sometimes go straight to their
 417                          * offset.  Of course, that may not be possible if the jump is
 418                          * from init -> core or vice. versa, so we need to generate an
 419                          * FDESC (and PLT etc) for that.
 420                          */
 421                       case R_IA64_PCREL21B:
 422                         if (!duplicate_reloc(rela, i))
 423                                 ret++;
 424                         break;
 425                 }
 426         }
 427         return ret;
 428 }
 429
 430 int
 431 module_frob_arch_sections (Elf_Ehdr *ehdr, Elf_Shdr *sechdrs, char *secstrings,
 432                            struct module *mod)
 433 {
 434         unsigned long core_plts = 0, init_plts = 0, gots = 0, fdescs = 0;
 435         Elf64_Shdr *s, *sechdrs_end = sechdrs + ehdr->e_shnum;
 436
 437         /*
 438          * To store the PLTs and function-descriptors, we expand the .text section for
 439          * core module-code and the .init.text section for initialization code.
 440          */
 441         for (s = sechdrs; s < sechdrs_end; ++s)
 442                 if (strcmp(".core.plt", secstrings + s->sh_name) == 0)
 443                         mod->arch.core_plt = s;
 444                 else if (strcmp(".init.plt", secstrings + s->sh_name) == 0)
 445                         mod->arch.init_plt = s;
 446                 else if (strcmp(".got", secstrings + s->sh_name) == 0)
 447                         mod->arch.got = s;
 448                 else if (strcmp(".opd", secstrings + s->sh_name) == 0)
 449                         mod->arch.opd = s;
 450                 else if (strcmp(".IA_64.unwind", secstrings + s->sh_name) == 0)
 451                         mod->arch.unwind = s;
 452 #ifdef CONFIG_PARAVIRT
 453                 else if (strcmp(".paravirt_bundles",
 454                                 secstrings + s->sh_name) == 0)
 455                         mod->arch.paravirt_bundles = s;
 456                 else if (strcmp(".paravirt_insts",
 457                                 secstrings + s->sh_name) == 0)
 458                         mod->arch.paravirt_insts = s;
 459 #endif
 460
 461         if (!mod->arch.core_plt || !mod->arch.init_plt || !mod->arch.got || !mod->arch.opd) {
 462                 printk(KERN_ERR "%s: sections missing\n", mod->name);
 463                 return -ENOEXEC;
 464         }
 465
 466         /* GOT and PLTs can occur in any relocated section... */
 467         for (s = sechdrs + 1; s < sechdrs_end; ++s) {
 468                 const Elf64_Rela *rels = (void *)ehdr + s->sh_offset;
 469                 unsigned long numrels = s->sh_size/sizeof(Elf64_Rela);
 470
 471                 if (s->sh_type != SHT_RELA)
 472                         continue;
 473
 474                 gots += count_gots(rels, numrels);
 475                 fdescs += count_fdescs(rels, numrels);
 476                 if (strstr(secstrings + s->sh_name, ".init"))
 477                         init_plts += count_plts(rels, numrels);
 478                 else
 479                         core_plts += count_plts(rels, numrels);
 480         }
 481
 482         mod->arch.core_plt->sh_type = SHT_NOBITS;
 483         mod->arch.core_plt->sh_flags = SHF_EXECINSTR | SHF_ALLOC;
 484         mod->arch.core_plt->sh_addralign = 16;
 485         mod->arch.core_plt->sh_size = core_plts * sizeof(struct plt_entry);
 486         mod->arch.init_plt->sh_type = SHT_NOBITS;
 487         mod->arch.init_plt->sh_flags = SHF_EXECINSTR | SHF_ALLOC;
 488         mod->arch.init_plt->sh_addralign = 16;
 489         mod->arch.init_plt->sh_size = init_plts * sizeof(struct plt_entry);
 490         mod->arch.got->sh_type = SHT_NOBITS;
 491         mod->arch.got->sh_flags = ARCH_SHF_SMALL | SHF_ALLOC;
 492         mod->arch.got->sh_addralign = 8;
 493         mod->arch.got->sh_size = gots * sizeof(struct got_entry);
 494         mod->arch.opd->sh_type = SHT_NOBITS;
 495         mod->arch.opd->sh_flags = SHF_ALLOC;
 496         mod->arch.opd->sh_addralign = 8;
 497         mod->arch.opd->sh_size = fdescs * sizeof(struct fdesc);
 498         DEBUGP("%s: core.plt=%lx, init.plt=%lx, got=%lx, fdesc=%lx\n",
 499                __func__, mod->arch.core_plt->sh_size, mod->arch.init_plt->sh_size,
 500                mod->arch.got->sh_size, mod->arch.opd->sh_size);
 501         return 0;
 502 }
 503
 504 static inline int
 505 in_init (const struct module *mod, uint64_t addr)
 506 {
 507         return addr - (uint64_t) mod->module_init < mod->init_size;
 508 }
 509
 510 static inline int
 511 in_core (const struct module *mod, uint64_t addr)
 512 {
 513         return addr - (uint64_t) mod->module_core < mod->core_size;
 514 }
 515
 516 static inline int
 517 is_internal (const struct module *mod, uint64_t value)
 518 {
 519         return in_init(mod, value) || in_core(mod, value);
 520 }
 521
 522 /*
 523  * Get gp-relative offset for the linkage-table entry of VALUE.
 524  */
 525 static uint64_t
 526 get_ltoff (struct module *mod, uint64_t value, int *okp)
 527 {
 528         struct got_entry *got, *e;
 529
 530         if (!*okp)
 531                 return 0;
 532
 533         got = (void *) mod->arch.got->sh_addr;
 534         for (e = got; e < got + mod->arch.next_got_entry; ++e)
 535                 if (e->val == value)
 536                         goto found;
 537
 538         /* Not enough GOT entries? */
 539         BUG_ON(e >= (struct got_entry *) (mod->arch.got->sh_addr + mod->arch.got->sh_size));
 540
 541         e->val = value;
 542         ++mod->arch.next_got_entry;
 543   found:
 544         return (uint64_t) e - mod->arch.gp;
 545 }
 546
 547 static inline int
 548 gp_addressable (struct module *mod, uint64_t value)
 549 {
 550         return value - mod->arch.gp + MAX_LTOFF/2 < MAX_LTOFF;
 551 }
 552
 553 /* Get PC-relative PLT entry for this value.  Returns 0 on failure. */
 554 static uint64_t
 555 get_plt (struct module *mod, const struct insn *insn, uint64_t value, int *okp)
 556 {
 557         struct plt_entry *plt, *plt_end;
 558         uint64_t target_ip, target_gp;
 559
 560         if (!*okp)
 561                 return 0;
 562
 563         if (in_init(mod, (uint64_t) insn)) {
 564                 plt = (void *) mod->arch.init_plt->sh_addr;
 565                 plt_end = (void *) plt + mod->arch.init_plt->sh_size;
 566         } else {
 567                 plt = (void *) mod->arch.core_plt->sh_addr;
 568                 plt_end = (void *) plt + mod->arch.core_plt->sh_size;
 569         }
 570
 571         /* "value" is a pointer to a function-descriptor; fetch the target ip/gp from it: */
 572         target_ip = ((uint64_t *) value)[0];
 573         target_gp = ((uint64_t *) value)[1];
 574
 575         /* Look for existing PLT entry. */
 576         while (plt->bundle[0][0]) {
 577                 if (plt_target(plt) == target_ip)
 578                         goto found;
 579                 if (++plt >= plt_end)
 580                         BUG();
 581         }
 582         *plt = ia64_plt_template;
 583         if (!patch_plt(mod, plt, target_ip, target_gp)) {
 584                 *okp = 0;
 585                 return 0;
 586         }
 587 #if ARCH_MODULE_DEBUG
 588         if (plt_target(plt) != target_ip) {
 589                 printk("%s: mistargeted PLT: wanted %lx, got %lx\n",
 590                        __func__, target_ip, plt_target(plt));
 591                 *okp = 0;
 592                 return 0;
 593         }
 594 #endif
 595   found:
 596         return (uint64_t) plt;
 597 }
 598
 599 /* Get function descriptor for VALUE. */
 600 static uint64_t
 601 get_fdesc (struct module *mod, uint64_t value, int *okp)
 602 {
 603         struct fdesc *fdesc = (void *) mod->arch.opd->sh_addr;
 604
 605         if (!*okp)
 606                 return 0;
 607
 608         if (!value) {
 609                 printk(KERN_ERR "%s: fdesc for zero requested!\n", mod->name);
 610                 return 0;
 611         }
 612
 613         if (!is_internal(mod, value))
 614                 /*
 615                  * If it's not a module-local entry-point, "value" already points to a
 616                  * function-descriptor.
 617                  */
 618                 return value;
 619
 620         /* Look for existing function descriptor. */
 621         while (fdesc->ip) {
 622                 if (fdesc->ip == value)
 623                         return (uint64_t)fdesc;
 624                 if ((uint64_t) ++fdesc >= mod->arch.opd->sh_addr + mod->arch.opd->sh_size)
 625                         BUG();
 626         }
 627
 628         /* Create new one */
 629         fdesc->ip = value;
 630         fdesc->gp = mod->arch.gp;
 631         return (uint64_t) fdesc;
 632 }
 633
 634 static inline int
 635 do_reloc (struct module *mod, uint8_t r_type, Elf64_Sym *sym, uint64_t addend,
 636           Elf64_Shdr *sec, void *location)
 637 {
 638         enum reloc_target_format format = (r_type >> FORMAT_SHIFT) & FORMAT_MASK;
 639         enum reloc_value_formula formula = (r_type >> VALUE_SHIFT) & VALUE_MASK;
 640         uint64_t val;
 641         int ok = 1;
 642
 643         val = sym->st_value + addend;
 644
 645         switch (formula) {
 646               case RV_SEGREL:   /* segment base is arbitrarily chosen to be 0 for kernel modules */
 647               case RV_DIRECT:
 648                 break;
 649
 650               case RV_GPREL:      val -= mod->arch.gp; break;
 651               case RV_LTREL:      val = get_ltoff(mod, val, &ok); break;
 652               case RV_PLTREL:     val = get_plt(mod, location, val, &ok); break;
 653               case RV_FPTR:       val = get_fdesc(mod, val, &ok); break;
 654               case RV_SECREL:     val -= sec->sh_addr; break;
 655               case RV_LTREL_FPTR: val = get_ltoff(mod, get_fdesc(mod, val, &ok), &ok); break;
 656
 657               case RV_PCREL:
 658                 switch (r_type) {
 659                       case R_IA64_PCREL21B:
 660                         if ((in_init(mod, val) && in_core(mod, (uint64_t)location)) ||
 661                             (in_core(mod, val) && in_init(mod, (uint64_t)location))) {
 662                                 /*
 663                                  * Init section may have been allocated far away from core,
 664                                  * if the branch won't reach, then allocate a plt for it.
 665                                  */
 666                                 uint64_t delta = ((int64_t)val - (int64_t)location) / 16;
 667                                 if (delta + (1 << 20) >= (1 << 21)) {
 668                                         val = get_fdesc(mod, val, &ok);
 669                                         val = get_plt(mod, location, val, &ok);
 670                                 }
 671                         } else if (!is_internal(mod, val))
 672                                 val = get_plt(mod, location, val, &ok);
 673                         /* FALL THROUGH */
 674                       default:
 675                         val -= bundle(location);
 676                         break;
 677
 678                       case R_IA64_PCREL32MSB:
 679                       case R_IA64_PCREL32LSB:
 680                       case R_IA64_PCREL64MSB:
 681                       case R_IA64_PCREL64LSB:
 682                         val -= (uint64_t) location;
 683                         break;
 684
 685                 }
 686                 switch (r_type) {
 687                       case R_IA64_PCREL60B: format = RF_INSN60; break;
 688                       case R_IA64_PCREL21B: format = RF_INSN21B; break;
 689                       case R_IA64_PCREL21M: format = RF_INSN21M; break;
 690                       case R_IA64_PCREL21F: format = RF_INSN21F; break;
 691                       default: break;
 692                 }
 693                 break;
 694
 695               case RV_BDREL:
 696                 val -= (uint64_t) (in_init(mod, val) ? mod->module_init : mod->module_core);
 697                 break;
 698
 699               case RV_LTV:
 700                 /* can link-time value relocs happen here?  */
 701                 BUG();
 702                 break;
 703
 704               case RV_PCREL2:
 705                 if (r_type == R_IA64_PCREL21BI) {
 706                         if (!is_internal(mod, val)) {
 707                                 printk(KERN_ERR "%s: %s reloc against "
 708                                         "non-local symbol (%lx)\n", __func__,
 709                                         reloc_name[r_type], (unsigned long)val);
 710                                 return -ENOEXEC;
 711                         }
 712                         format = RF_INSN21B;
 713                 }
 714                 val -= bundle(location);
 715                 break;
 716
 717               case RV_SPECIAL:
 718                 switch (r_type) {
 719                       case R_IA64_IPLTMSB:
 720                       case R_IA64_IPLTLSB:
 721                         val = get_fdesc(mod, get_plt(mod, location, val, &ok), &ok);
 722                         format = RF_64LSB;
 723                         if (r_type == R_IA64_IPLTMSB)
 724                                 format = RF_64MSB;
 725                         break;
 726
 727                       case R_IA64_SUB:
 728                         val = addend - sym->st_value;
 729                         format = RF_INSN64;
 730                         break;
 731
 732                       case R_IA64_LTOFF22X:
 733                         if (gp_addressable(mod, val))
 734                                 val -= mod->arch.gp;
 735                         else
 736                                 val = get_ltoff(mod, val, &ok);
 737                         format = RF_INSN22;
 738                         break;
 739
 740                       case R_IA64_LDXMOV:
 741                         if (gp_addressable(mod, val)) {
 742                                 /* turn "ld8" into "mov": */
 743                                 DEBUGP("%s: patching ld8 at %p to mov\n", __func__, location);
 744                                 ia64_patch((u64) location, 0x1fff80fe000UL, 0x10000000000UL);
 745                         }
 746                         return 0;
 747
 748                       default:
 749                         if (reloc_name[r_type])
 750                                 printk(KERN_ERR "%s: special reloc %s not supported",
 751                                        mod->name, reloc_name[r_type]);
 752                         else
 753                                 printk(KERN_ERR "%s: unknown special reloc %x\n",
 754                                        mod->name, r_type);
 755                         return -ENOEXEC;
 756                 }
 757                 break;
 758
 759               case RV_TPREL:
 760               case RV_LTREL_TPREL:
 761               case RV_DTPMOD:
 762               case RV_LTREL_DTPMOD:
 763               case RV_DTPREL:
 764               case RV_LTREL_DTPREL:
 765                 printk(KERN_ERR "%s: %s reloc not supported\n",
 766                        mod->name, reloc_name[r_type] ? reloc_name[r_type] : "?");
 767                 return -ENOEXEC;
 768
 769               default:
 770                 printk(KERN_ERR "%s: unknown reloc %x\n", mod->name, r_type);
 771                 return -ENOEXEC;
 772         }
 773
 774         if (!ok)
 775                 return -ENOEXEC;
 776
 777         DEBUGP("%s: [%p]<-%016lx = %s(%lx)\n", __func__, location, val,
 778                reloc_name[r_type] ? reloc_name[r_type] : "?", sym->st_value + addend);
 779
 780         switch (format) {
 781               case RF_INSN21B:  ok = apply_imm21b(mod, location, (int64_t) val / 16); break;
 782               case RF_INSN22:   ok = apply_imm22(mod, location, val); break;
 783               case RF_INSN64:   ok = apply_imm64(mod, location, val); break;
 784               case RF_INSN60:   ok = apply_imm60(mod, location, (int64_t) val / 16); break;
 785               case RF_32LSB:    put_unaligned(val, (uint32_t *) location); break;
 786               case RF_64LSB:    put_unaligned(val, (uint64_t *) location); break;
 787               case RF_32MSB:    /* ia64 Linux is little-endian... */
 788               case RF_64MSB:    /* ia64 Linux is little-endian... */
 789               case RF_INSN14:   /* must be within-module, i.e., resolved by "ld -r" */
 790               case RF_INSN21M:  /* must be within-module, i.e., resolved by "ld -r" */
 791               case RF_INSN21F:  /* must be within-module, i.e., resolved by "ld -r" */
 792                 printk(KERN_ERR "%s: format %u needed by %s reloc is not supported\n",
 793                        mod->name, format, reloc_name[r_type] ? reloc_name[r_type] : "?");
 794                 return -ENOEXEC;
 795
 796               default:
 797                 printk(KERN_ERR "%s: relocation %s resulted in unknown format %u\n",
 798                        mod->name, reloc_name[r_type] ? reloc_name[r_type] : "?", format);
 799                 return -ENOEXEC;
 800         }
 801         return ok ? 0 : -ENOEXEC;
 802 }
 803
 804 int
 805 apply_relocate_add (Elf64_Shdr *sechdrs, const char *strtab, unsigned int symindex,
 806                     unsigned int relsec, struct module *mod)
 807 {
 808         unsigned int i, n = sechdrs[relsec].sh_size / sizeof(Elf64_Rela);
 809         Elf64_Rela *rela = (void *) sechdrs[relsec].sh_addr;
 810         Elf64_Shdr *target_sec;
 811         int ret;
 812
 813         DEBUGP("%s: applying section %u (%u relocs) to %u\n", __func__,
 814                relsec, n, sechdrs[relsec].sh_info);
 815
 816         target_sec = sechdrs + sechdrs[relsec].sh_info;
 817
 818         if (target_sec->sh_entsize == ~0UL)
 819                 /*
 820                  * If target section wasn't allocated, we don't need to relocate it.
 821                  * Happens, e.g., for debug sections.
 822                  */
 823                 return 0;
 824
 825         if (!mod->arch.gp) {
 826                 /*
 827                  * XXX Should have an arch-hook for running this after final section
 828                  *     addresses have been selected...
 829                  */
 830                 uint64_t gp;
 831                 if (mod->core_size > MAX_LTOFF)
 832                         /*
 833                          * This takes advantage of fact that SHF_ARCH_SMALL gets allocated
 834                          * at the end of the module.
 835                          */
 836                         gp = mod->core_size - MAX_LTOFF / 2;
 837                 else
 838                         gp = mod->core_size / 2;
 839                 gp = (uint64_t) mod->module_core + ((gp + 7) & -8);
 840                 mod->arch.gp = gp;
 841                 DEBUGP("%s: placing gp at 0x%lx\n", __func__, gp);
 842         }
 843
 844         for (i = 0; i < n; i++) {
 845                 ret = do_reloc(mod, ELF64_R_TYPE(rela[i].r_info),
 846                                ((Elf64_Sym *) sechdrs[symindex].sh_addr
 847                                 + ELF64_R_SYM(rela[i].r_info)),
 848                                rela[i].r_addend, target_sec,
 849                                (void *) target_sec->sh_addr + rela[i].r_offset);
 850                 if (ret < 0)
 851                         return ret;
 852         }
 853         return 0;
 854 }
 855
 856 int
 857 apply_relocate (Elf64_Shdr *sechdrs, const char *strtab, unsigned int symindex,
 858                 unsigned int relsec, struct module *mod)
 859 {
 860         printk(KERN_ERR "module %s: REL relocs in section %u unsupported\n", mod->name, relsec);
 861         return -ENOEXEC;
 862 }
 863
 864 /*
 865  * Modules contain a single unwind table which covers both the core and the init text
 866  * sections but since the two are not contiguous, we need to split this table up such that
 867  * we can register (and unregister) each "segment" separately.  Fortunately, this sounds
 868  * more complicated than it really is.
 869  */
 870 static void
 871 register_unwind_table (struct module *mod)
 872 {
 873         struct unw_table_entry *start = (void *) mod->arch.unwind->sh_addr;
 874         struct unw_table_entry *end = start + mod->arch.unwind->sh_size / sizeof (*start);
 875         struct unw_table_entry tmp, *e1, *e2, *core, *init;
 876         unsigned long num_init = 0, num_core = 0;
 877
 878         /* First, count how many init and core unwind-table entries there are.  */
 879         for (e1 = start; e1 < end; ++e1)
 880                 if (in_init(mod, e1->start_offset))
 881                         ++num_init;
 882                 else
 883                         ++num_core;
 884         /*
 885          * Second, sort the table such that all unwind-table entries for the init and core
 886          * text sections are nicely separated.  We do this with a stupid bubble sort
 887          * (unwind tables don't get ridiculously huge).
 888          */
 889         for (e1 = start; e1 < end; ++e1) {
 890                 for (e2 = e1 + 1; e2 < end; ++e2) {
 891                         if (e2->start_offset < e1->start_offset) {
 892                                 tmp = *e1;
 893                                 *e1 = *e2;
 894                                 *e2 = tmp;
 895                         }
 896                 }
 897         }
 898         /*
 899          * Third, locate the init and core segments in the unwind table:
 900          */
 901         if (in_init(mod, start->start_offset)) {
 902                 init = start;
 903                 core = start + num_init;
 904         } else {
 905                 core = start;
 906                 init = start + num_core;
 907         }
 908
 909         DEBUGP("%s: name=%s, gp=%lx, num_init=%lu, num_core=%lu\n", __func__,
 910                mod->name, mod->arch.gp, num_init, num_core);
 911
 912         /*
 913          * Fourth, register both tables (if not empty).
 914          */
 915         if (num_core > 0) {
 916                 mod->arch.core_unw_table = unw_add_unwind_table(mod->name, 0, mod->arch.gp,
 917                                                                 core, core + num_core);
 918                 DEBUGP("%s:  core: handle=%p [%p-%p)\n", __func__,
 919                        mod->arch.core_unw_table, core, core + num_core);
 920         }
 921         if (num_init > 0) {
 922                 mod->arch.init_unw_table = unw_add_unwind_table(mod->name, 0, mod->arch.gp,
 923                                                                 init, init + num_init);
 924                 DEBUGP("%s:  init: handle=%p [%p-%p)\n", __func__,
 925                        mod->arch.init_unw_table, init, init + num_init);
 926         }
 927 }
 928
 929 int
 930 module_finalize (const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs, struct module *mod)
 931 {
 932         DEBUGP("%s: init: entry=%p\n", __func__, mod->init);
 933         if (mod->arch.unwind)
 934                 register_unwind_table(mod);
 935 #ifdef CONFIG_PARAVIRT
 936         if (mod->arch.paravirt_bundles) {
 937                 struct paravirt_patch_site_bundle *start =
 938                         (struct paravirt_patch_site_bundle *)
 939                         mod->arch.paravirt_bundles->sh_addr;
 940                 struct paravirt_patch_site_bundle *end =
 941                         (struct paravirt_patch_site_bundle *)
 942                         (mod->arch.paravirt_bundles->sh_addr +
 943                          mod->arch.paravirt_bundles->sh_size);
 944
 945                 paravirt_patch_apply_bundle(start, end);
 946         }
 947         if (mod->arch.paravirt_insts) {
 948                 struct paravirt_patch_site_inst *start =
 949                         (struct paravirt_patch_site_inst *)
 950                         mod->arch.paravirt_insts->sh_addr;
 951                 struct paravirt_patch_site_inst *end =
 952                         (struct paravirt_patch_site_inst *)
 953                         (mod->arch.paravirt_insts->sh_addr +
 954                          mod->arch.paravirt_insts->sh_size);
 955
 956                 paravirt_patch_apply_inst(start, end);
 957         }
 958 #endif
 959         return 0;
 960 }
 961
 962 void
 963 module_arch_cleanup (struct module *mod)
 964 {
 965         if (mod->arch.init_unw_table)
 966                 unw_remove_unwind_table(mod->arch.init_unw_table);
 967         if (mod->arch.core_unw_table)
 968                 unw_remove_unwind_table(mod->arch.core_unw_table);
 969 }