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