1// SPDX-License-Identifier: GPL-2.0 2/* This is included from relocs_32/64.c */ 3 4#define ElfW(type) _ElfW(ELF_BITS, type) 5#define _ElfW(bits, type) __ElfW(bits, type) 6#define __ElfW(bits, type) Elf##bits##_##type 7 8#define Elf_Addr ElfW(Addr) 9#define Elf_Ehdr ElfW(Ehdr) 10#define Elf_Phdr ElfW(Phdr) 11#define Elf_Shdr ElfW(Shdr) 12#define Elf_Sym ElfW(Sym) 13 14static Elf_Ehdr ehdr; 15static unsigned long shnum; 16static unsigned int shstrndx; 17static unsigned int shsymtabndx; 18static unsigned int shxsymtabndx; 19 20static int sym_index(Elf_Sym *sym); 21 22struct relocs { 23 uint32_t *offset; 24 unsigned long count; 25 unsigned long size; 26}; 27 28static struct relocs relocs16; 29static struct relocs relocs32; 30#if ELF_BITS == 64 31static struct relocs relocs32neg; 32static struct relocs relocs64; 33#define FMT PRIu64 34#else 35#define FMT PRIu32 36#endif 37 38struct section { 39 Elf_Shdr shdr; 40 struct section *link; 41 Elf_Sym *symtab; 42 Elf32_Word *xsymtab; 43 Elf_Rel *reltab; 44 char *strtab; 45}; 46static struct section *secs; 47 48static const char * const sym_regex_kernel[S_NSYMTYPES] = { 49/* 50 * Following symbols have been audited. There values are constant and do 51 * not change if bzImage is loaded at a different physical address than 52 * the address for which it has been compiled. Don't warn user about 53 * absolute relocations present w.r.t these symbols. 54 */ 55 [S_ABS] = 56 "^(xen_irq_disable_direct_reloc$|" 57 "xen_save_fl_direct_reloc$|" 58 "VDSO|" 59 "__kcfi_typeid_|" 60 "__crc_)", 61 62/* 63 * These symbols are known to be relative, even if the linker marks them 64 * as absolute (typically defined outside any section in the linker script.) 65 */ 66 [S_REL] = 67 "^(__init_(begin|end)|" 68 "__x86_cpu_dev_(start|end)|" 69 "__alt_instructions(_end)?|" 70 "(__iommu_table|__apicdrivers|__smp_locks)(_end)?|" 71 "__(start|end)_pci_.*|" 72#if CONFIG_FW_LOADER 73 "__(start|end)_builtin_fw|" 74#endif 75 "__(start|stop)___ksymtab(_gpl)?|" 76 "__(start|stop)___kcrctab(_gpl)?|" 77 "__(start|stop)___param|" 78 "__(start|stop)___modver|" 79 "__(start|stop)___bug_table|" 80 "__tracedata_(start|end)|" 81 "__(start|stop)_notes|" 82 "__end_rodata|" 83 "__end_rodata_aligned|" 84 "__initramfs_start|" 85 "(jiffies|jiffies_64)|" 86#if ELF_BITS == 64 87 "__per_cpu_load|" 88 "init_per_cpu__.*|" 89 "__end_rodata_hpage_align|" 90#endif 91 "__vvar_page|" 92 "_end)$" 93}; 94 95 96static const char * const sym_regex_realmode[S_NSYMTYPES] = { 97/* 98 * These symbols are known to be relative, even if the linker marks them 99 * as absolute (typically defined outside any section in the linker script.) 100 */ 101 [S_REL] = 102 "^pa_", 103 104/* 105 * These are 16-bit segment symbols when compiling 16-bit code. 106 */ 107 [S_SEG] = 108 "^real_mode_seg$", 109 110/* 111 * These are offsets belonging to segments, as opposed to linear addresses, 112 * when compiling 16-bit code. 113 */ 114 [S_LIN] = 115 "^pa_", 116}; 117 118static const char * const *sym_regex; 119 120static regex_t sym_regex_c[S_NSYMTYPES]; 121static int is_reloc(enum symtype type, const char *sym_name) 122{ 123 return sym_regex[type] && 124 !regexec(&sym_regex_c[type], sym_name, 0, NULL, 0); 125} 126 127static void regex_init(int use_real_mode) 128{ 129 char errbuf[128]; 130 int err; 131 int i; 132 133 if (use_real_mode) 134 sym_regex = sym_regex_realmode; 135 else 136 sym_regex = sym_regex_kernel; 137 138 for (i = 0; i < S_NSYMTYPES; i++) { 139 if (!sym_regex[i]) 140 continue; 141 142 err = regcomp(&sym_regex_c[i], sym_regex[i], 143 REG_EXTENDED|REG_NOSUB); 144 145 if (err) { 146 regerror(err, &sym_regex_c[i], errbuf, sizeof(errbuf)); 147 die("%s", errbuf); 148 } 149 } 150} 151 152static const char *sym_type(unsigned type) 153{ 154 static const char *type_name[] = { 155#define SYM_TYPE(X) [X] = #X 156 SYM_TYPE(STT_NOTYPE), 157 SYM_TYPE(STT_OBJECT), 158 SYM_TYPE(STT_FUNC), 159 SYM_TYPE(STT_SECTION), 160 SYM_TYPE(STT_FILE), 161 SYM_TYPE(STT_COMMON), 162 SYM_TYPE(STT_TLS), 163#undef SYM_TYPE 164 }; 165 const char *name = "unknown sym type name"; 166 if (type < ARRAY_SIZE(type_name)) { 167 name = type_name[type]; 168 } 169 return name; 170} 171 172static const char *sym_bind(unsigned bind) 173{ 174 static const char *bind_name[] = { 175#define SYM_BIND(X) [X] = #X 176 SYM_BIND(STB_LOCAL), 177 SYM_BIND(STB_GLOBAL), 178 SYM_BIND(STB_WEAK), 179#undef SYM_BIND 180 }; 181 const char *name = "unknown sym bind name"; 182 if (bind < ARRAY_SIZE(bind_name)) { 183 name = bind_name[bind]; 184 } 185 return name; 186} 187 188static const char *sym_visibility(unsigned visibility) 189{ 190 static const char *visibility_name[] = { 191#define SYM_VISIBILITY(X) [X] = #X 192 SYM_VISIBILITY(STV_DEFAULT), 193 SYM_VISIBILITY(STV_INTERNAL), 194 SYM_VISIBILITY(STV_HIDDEN), 195 SYM_VISIBILITY(STV_PROTECTED), 196#undef SYM_VISIBILITY 197 }; 198 const char *name = "unknown sym visibility name"; 199 if (visibility < ARRAY_SIZE(visibility_name)) { 200 name = visibility_name[visibility]; 201 } 202 return name; 203} 204 205static const char *rel_type(unsigned type) 206{ 207 static const char *type_name[] = { 208#define REL_TYPE(X) [X] = #X 209#if ELF_BITS == 64 210 REL_TYPE(R_X86_64_NONE), 211 REL_TYPE(R_X86_64_64), 212 REL_TYPE(R_X86_64_PC64), 213 REL_TYPE(R_X86_64_PC32), 214 REL_TYPE(R_X86_64_GOT32), 215 REL_TYPE(R_X86_64_PLT32), 216 REL_TYPE(R_X86_64_COPY), 217 REL_TYPE(R_X86_64_GLOB_DAT), 218 REL_TYPE(R_X86_64_JUMP_SLOT), 219 REL_TYPE(R_X86_64_RELATIVE), 220 REL_TYPE(R_X86_64_GOTPCREL), 221 REL_TYPE(R_X86_64_32), 222 REL_TYPE(R_X86_64_32S), 223 REL_TYPE(R_X86_64_16), 224 REL_TYPE(R_X86_64_PC16), 225 REL_TYPE(R_X86_64_8), 226 REL_TYPE(R_X86_64_PC8), 227#else 228 REL_TYPE(R_386_NONE), 229 REL_TYPE(R_386_32), 230 REL_TYPE(R_386_PC32), 231 REL_TYPE(R_386_GOT32), 232 REL_TYPE(R_386_PLT32), 233 REL_TYPE(R_386_COPY), 234 REL_TYPE(R_386_GLOB_DAT), 235 REL_TYPE(R_386_JMP_SLOT), 236 REL_TYPE(R_386_RELATIVE), 237 REL_TYPE(R_386_GOTOFF), 238 REL_TYPE(R_386_GOTPC), 239 REL_TYPE(R_386_8), 240 REL_TYPE(R_386_PC8), 241 REL_TYPE(R_386_16), 242 REL_TYPE(R_386_PC16), 243#endif 244#undef REL_TYPE 245 }; 246 const char *name = "unknown type rel type name"; 247 if (type < ARRAY_SIZE(type_name) && type_name[type]) { 248 name = type_name[type]; 249 } 250 return name; 251} 252 253static const char *sec_name(unsigned shndx) 254{ 255 const char *sec_strtab; 256 const char *name; 257 sec_strtab = secs[shstrndx].strtab; 258 name = "<noname>"; 259 if (shndx < shnum) { 260 name = sec_strtab + secs[shndx].shdr.sh_name; 261 } 262 else if (shndx == SHN_ABS) { 263 name = "ABSOLUTE"; 264 } 265 else if (shndx == SHN_COMMON) { 266 name = "COMMON"; 267 } 268 return name; 269} 270 271static const char *sym_name(const char *sym_strtab, Elf_Sym *sym) 272{ 273 const char *name; 274 name = "<noname>"; 275 if (sym->st_name) { 276 name = sym_strtab + sym->st_name; 277 } 278 else { 279 name = sec_name(sym_index(sym)); 280 } 281 return name; 282} 283 284static Elf_Sym *sym_lookup(const char *symname) 285{ 286 int i; 287 for (i = 0; i < shnum; i++) { 288 struct section *sec = &secs[i]; 289 long nsyms; 290 char *strtab; 291 Elf_Sym *symtab; 292 Elf_Sym *sym; 293 294 if (sec->shdr.sh_type != SHT_SYMTAB) 295 continue; 296 297 nsyms = sec->shdr.sh_size/sizeof(Elf_Sym); 298 symtab = sec->symtab; 299 strtab = sec->link->strtab; 300 301 for (sym = symtab; --nsyms >= 0; sym++) { 302 if (!sym->st_name) 303 continue; 304 if (strcmp(symname, strtab + sym->st_name) == 0) 305 return sym; 306 } 307 } 308 return 0; 309} 310 311#if BYTE_ORDER == LITTLE_ENDIAN 312#define le16_to_cpu(val) (val) 313#define le32_to_cpu(val) (val) 314#define le64_to_cpu(val) (val) 315#endif 316#if BYTE_ORDER == BIG_ENDIAN 317#define le16_to_cpu(val) bswap_16(val) 318#define le32_to_cpu(val) bswap_32(val) 319#define le64_to_cpu(val) bswap_64(val) 320#endif 321 322static uint16_t elf16_to_cpu(uint16_t val) 323{ 324 return le16_to_cpu(val); 325} 326 327static uint32_t elf32_to_cpu(uint32_t val) 328{ 329 return le32_to_cpu(val); 330} 331 332#define elf_half_to_cpu(x) elf16_to_cpu(x) 333#define elf_word_to_cpu(x) elf32_to_cpu(x) 334 335#if ELF_BITS == 64 336static uint64_t elf64_to_cpu(uint64_t val) 337{ 338 return le64_to_cpu(val); 339} 340#define elf_addr_to_cpu(x) elf64_to_cpu(x) 341#define elf_off_to_cpu(x) elf64_to_cpu(x) 342#define elf_xword_to_cpu(x) elf64_to_cpu(x) 343#else 344#define elf_addr_to_cpu(x) elf32_to_cpu(x) 345#define elf_off_to_cpu(x) elf32_to_cpu(x) 346#define elf_xword_to_cpu(x) elf32_to_cpu(x) 347#endif 348 349static int sym_index(Elf_Sym *sym) 350{ 351 Elf_Sym *symtab = secs[shsymtabndx].symtab; 352 Elf32_Word *xsymtab = secs[shxsymtabndx].xsymtab; 353 unsigned long offset; 354 int index; 355 356 if (sym->st_shndx != SHN_XINDEX) 357 return sym->st_shndx; 358 359 /* calculate offset of sym from head of table. */ 360 offset = (unsigned long)sym - (unsigned long)symtab; 361 index = offset / sizeof(*sym); 362 363 return elf32_to_cpu(xsymtab[index]); 364} 365 366static void read_ehdr(FILE *fp) 367{ 368 if (fread(&ehdr, sizeof(ehdr), 1, fp) != 1) { 369 die("Cannot read ELF header: %s\n", 370 strerror(errno)); 371 } 372 if (memcmp(ehdr.e_ident, ELFMAG, SELFMAG) != 0) { 373 die("No ELF magic\n"); 374 } 375 if (ehdr.e_ident[EI_CLASS] != ELF_CLASS) { 376 die("Not a %d bit executable\n", ELF_BITS); 377 } 378 if (ehdr.e_ident[EI_DATA] != ELFDATA2LSB) { 379 die("Not a LSB ELF executable\n"); 380 } 381 if (ehdr.e_ident[EI_VERSION] != EV_CURRENT) { 382 die("Unknown ELF version\n"); 383 } 384 /* Convert the fields to native endian */ 385 ehdr.e_type = elf_half_to_cpu(ehdr.e_type); 386 ehdr.e_machine = elf_half_to_cpu(ehdr.e_machine); 387 ehdr.e_version = elf_word_to_cpu(ehdr.e_version); 388 ehdr.e_entry = elf_addr_to_cpu(ehdr.e_entry); 389 ehdr.e_phoff = elf_off_to_cpu(ehdr.e_phoff); 390 ehdr.e_shoff = elf_off_to_cpu(ehdr.e_shoff); 391 ehdr.e_flags = elf_word_to_cpu(ehdr.e_flags); 392 ehdr.e_ehsize = elf_half_to_cpu(ehdr.e_ehsize); 393 ehdr.e_phentsize = elf_half_to_cpu(ehdr.e_phentsize); 394 ehdr.e_phnum = elf_half_to_cpu(ehdr.e_phnum); 395 ehdr.e_shentsize = elf_half_to_cpu(ehdr.e_shentsize); 396 ehdr.e_shnum = elf_half_to_cpu(ehdr.e_shnum); 397 ehdr.e_shstrndx = elf_half_to_cpu(ehdr.e_shstrndx); 398 399 shnum = ehdr.e_shnum; 400 shstrndx = ehdr.e_shstrndx; 401 402 if ((ehdr.e_type != ET_EXEC) && (ehdr.e_type != ET_DYN)) 403 die("Unsupported ELF header type\n"); 404 if (ehdr.e_machine != ELF_MACHINE) 405 die("Not for %s\n", ELF_MACHINE_NAME); 406 if (ehdr.e_version != EV_CURRENT) 407 die("Unknown ELF version\n"); 408 if (ehdr.e_ehsize != sizeof(Elf_Ehdr)) 409 die("Bad ELF header size\n"); 410 if (ehdr.e_phentsize != sizeof(Elf_Phdr)) 411 die("Bad program header entry\n"); 412 if (ehdr.e_shentsize != sizeof(Elf_Shdr)) 413 die("Bad section header entry\n"); 414 415 416 if (shnum == SHN_UNDEF || shstrndx == SHN_XINDEX) { 417 Elf_Shdr shdr; 418 419 if (fseek(fp, ehdr.e_shoff, SEEK_SET) < 0) 420 die("Seek to %" FMT " failed: %s\n", ehdr.e_shoff, strerror(errno)); 421 422 if (fread(&shdr, sizeof(shdr), 1, fp) != 1) 423 die("Cannot read initial ELF section header: %s\n", strerror(errno)); 424 425 if (shnum == SHN_UNDEF) 426 shnum = elf_xword_to_cpu(shdr.sh_size); 427 428 if (shstrndx == SHN_XINDEX) 429 shstrndx = elf_word_to_cpu(shdr.sh_link); 430 } 431 432 if (shstrndx >= shnum) 433 die("String table index out of bounds\n"); 434} 435 436static void read_shdrs(FILE *fp) 437{ 438 int i; 439 Elf_Shdr shdr; 440 441 secs = calloc(shnum, sizeof(struct section)); 442 if (!secs) { 443 die("Unable to allocate %ld section headers\n", 444 shnum); 445 } 446 if (fseek(fp, ehdr.e_shoff, SEEK_SET) < 0) { 447 die("Seek to %" FMT " failed: %s\n", 448 ehdr.e_shoff, strerror(errno)); 449 } 450 for (i = 0; i < shnum; i++) { 451 struct section *sec = &secs[i]; 452 if (fread(&shdr, sizeof(shdr), 1, fp) != 1) 453 die("Cannot read ELF section headers %d/%ld: %s\n", 454 i, shnum, strerror(errno)); 455 sec->shdr.sh_name = elf_word_to_cpu(shdr.sh_name); 456 sec->shdr.sh_type = elf_word_to_cpu(shdr.sh_type); 457 sec->shdr.sh_flags = elf_xword_to_cpu(shdr.sh_flags); 458 sec->shdr.sh_addr = elf_addr_to_cpu(shdr.sh_addr); 459 sec->shdr.sh_offset = elf_off_to_cpu(shdr.sh_offset); 460 sec->shdr.sh_size = elf_xword_to_cpu(shdr.sh_size); 461 sec->shdr.sh_link = elf_word_to_cpu(shdr.sh_link); 462 sec->shdr.sh_info = elf_word_to_cpu(shdr.sh_info); 463 sec->shdr.sh_addralign = elf_xword_to_cpu(shdr.sh_addralign); 464 sec->shdr.sh_entsize = elf_xword_to_cpu(shdr.sh_entsize); 465 if (sec->shdr.sh_link < shnum) 466 sec->link = &secs[sec->shdr.sh_link]; 467 } 468 469} 470 471static void read_strtabs(FILE *fp) 472{ 473 int i; 474 for (i = 0; i < shnum; i++) { 475 struct section *sec = &secs[i]; 476 if (sec->shdr.sh_type != SHT_STRTAB) { 477 continue; 478 } 479 sec->strtab = malloc(sec->shdr.sh_size); 480 if (!sec->strtab) { 481 die("malloc of %" FMT " bytes for strtab failed\n", 482 sec->shdr.sh_size); 483 } 484 if (fseek(fp, sec->shdr.sh_offset, SEEK_SET) < 0) { 485 die("Seek to %" FMT " failed: %s\n", 486 sec->shdr.sh_offset, strerror(errno)); 487 } 488 if (fread(sec->strtab, 1, sec->shdr.sh_size, fp) 489 != sec->shdr.sh_size) { 490 die("Cannot read symbol table: %s\n", 491 strerror(errno)); 492 } 493 } 494} 495 496static void read_symtabs(FILE *fp) 497{ 498 int i,j; 499 500 for (i = 0; i < shnum; i++) { 501 struct section *sec = &secs[i]; 502 int num_syms; 503 504 switch (sec->shdr.sh_type) { 505 case SHT_SYMTAB_SHNDX: 506 sec->xsymtab = malloc(sec->shdr.sh_size); 507 if (!sec->xsymtab) { 508 die("malloc of %" FMT " bytes for xsymtab failed\n", 509 sec->shdr.sh_size); 510 } 511 if (fseek(fp, sec->shdr.sh_offset, SEEK_SET) < 0) { 512 die("Seek to %" FMT " failed: %s\n", 513 sec->shdr.sh_offset, strerror(errno)); 514 } 515 if (fread(sec->xsymtab, 1, sec->shdr.sh_size, fp) 516 != sec->shdr.sh_size) { 517 die("Cannot read extended symbol table: %s\n", 518 strerror(errno)); 519 } 520 shxsymtabndx = i; 521 continue; 522 523 case SHT_SYMTAB: 524 num_syms = sec->shdr.sh_size / sizeof(Elf_Sym); 525 526 sec->symtab = malloc(sec->shdr.sh_size); 527 if (!sec->symtab) { 528 die("malloc of %" FMT " bytes for symtab failed\n", 529 sec->shdr.sh_size); 530 } 531 if (fseek(fp, sec->shdr.sh_offset, SEEK_SET) < 0) { 532 die("Seek to %" FMT " failed: %s\n", 533 sec->shdr.sh_offset, strerror(errno)); 534 } 535 if (fread(sec->symtab, 1, sec->shdr.sh_size, fp) 536 != sec->shdr.sh_size) { 537 die("Cannot read symbol table: %s\n", 538 strerror(errno)); 539 } 540 for (j = 0; j < num_syms; j++) { 541 Elf_Sym *sym = &sec->symtab[j]; 542 543 sym->st_name = elf_word_to_cpu(sym->st_name); 544 sym->st_value = elf_addr_to_cpu(sym->st_value); 545 sym->st_size = elf_xword_to_cpu(sym->st_size); 546 sym->st_shndx = elf_half_to_cpu(sym->st_shndx); 547 } 548 shsymtabndx = i; 549 continue; 550 551 default: 552 continue; 553 } 554 } 555} 556 557 558static void read_relocs(FILE *fp) 559{ 560 int i,j; 561 for (i = 0; i < shnum; i++) { 562 struct section *sec = &secs[i]; 563 if (sec->shdr.sh_type != SHT_REL_TYPE) { 564 continue; 565 } 566 sec->reltab = malloc(sec->shdr.sh_size); 567 if (!sec->reltab) { 568 die("malloc of %" FMT " bytes for relocs failed\n", 569 sec->shdr.sh_size); 570 } 571 if (fseek(fp, sec->shdr.sh_offset, SEEK_SET) < 0) { 572 die("Seek to %" FMT " failed: %s\n", 573 sec->shdr.sh_offset, strerror(errno)); 574 } 575 if (fread(sec->reltab, 1, sec->shdr.sh_size, fp) 576 != sec->shdr.sh_size) { 577 die("Cannot read symbol table: %s\n", 578 strerror(errno)); 579 } 580 for (j = 0; j < sec->shdr.sh_size/sizeof(Elf_Rel); j++) { 581 Elf_Rel *rel = &sec->reltab[j]; 582 rel->r_offset = elf_addr_to_cpu(rel->r_offset); 583 rel->r_info = elf_xword_to_cpu(rel->r_info); 584#if (SHT_REL_TYPE == SHT_RELA) 585 rel->r_addend = elf_xword_to_cpu(rel->r_addend); 586#endif 587 } 588 } 589} 590 591 592static void print_absolute_symbols(void) 593{ 594 int i; 595 const char *format; 596 597 if (ELF_BITS == 64) 598 format = "%5d %016"PRIx64" %5"PRId64" %10s %10s %12s %s\n"; 599 else 600 format = "%5d %08"PRIx32" %5"PRId32" %10s %10s %12s %s\n"; 601 602 printf("Absolute symbols\n"); 603 printf(" Num: Value Size Type Bind Visibility Name\n"); 604 for (i = 0; i < shnum; i++) { 605 struct section *sec = &secs[i]; 606 char *sym_strtab; 607 int j; 608 609 if (sec->shdr.sh_type != SHT_SYMTAB) { 610 continue; 611 } 612 sym_strtab = sec->link->strtab; 613 for (j = 0; j < sec->shdr.sh_size/sizeof(Elf_Sym); j++) { 614 Elf_Sym *sym; 615 const char *name; 616 sym = &sec->symtab[j]; 617 name = sym_name(sym_strtab, sym); 618 if (sym->st_shndx != SHN_ABS) { 619 continue; 620 } 621 printf(format, 622 j, sym->st_value, sym->st_size, 623 sym_type(ELF_ST_TYPE(sym->st_info)), 624 sym_bind(ELF_ST_BIND(sym->st_info)), 625 sym_visibility(ELF_ST_VISIBILITY(sym->st_other)), 626 name); 627 } 628 } 629 printf("\n"); 630} 631 632static void print_absolute_relocs(void) 633{ 634 int i, printed = 0; 635 const char *format; 636 637 if (ELF_BITS == 64) 638 format = "%016"PRIx64" %016"PRIx64" %10s %016"PRIx64" %s\n"; 639 else 640 format = "%08"PRIx32" %08"PRIx32" %10s %08"PRIx32" %s\n"; 641 642 for (i = 0; i < shnum; i++) { 643 struct section *sec = &secs[i]; 644 struct section *sec_applies, *sec_symtab; 645 char *sym_strtab; 646 Elf_Sym *sh_symtab; 647 int j; 648 if (sec->shdr.sh_type != SHT_REL_TYPE) { 649 continue; 650 } 651 sec_symtab = sec->link; 652 sec_applies = &secs[sec->shdr.sh_info]; 653 if (!(sec_applies->shdr.sh_flags & SHF_ALLOC)) { 654 continue; 655 } 656 /* 657 * Do not perform relocations in .notes section; any 658 * values there are meant for pre-boot consumption (e.g. 659 * startup_xen). 660 */ 661 if (sec_applies->shdr.sh_type == SHT_NOTE) { 662 continue; 663 } 664 sh_symtab = sec_symtab->symtab; 665 sym_strtab = sec_symtab->link->strtab; 666 for (j = 0; j < sec->shdr.sh_size/sizeof(Elf_Rel); j++) { 667 Elf_Rel *rel; 668 Elf_Sym *sym; 669 const char *name; 670 rel = &sec->reltab[j]; 671 sym = &sh_symtab[ELF_R_SYM(rel->r_info)]; 672 name = sym_name(sym_strtab, sym); 673 if (sym->st_shndx != SHN_ABS) { 674 continue; 675 } 676 677 /* Absolute symbols are not relocated if bzImage is 678 * loaded at a non-compiled address. Display a warning 679 * to user at compile time about the absolute 680 * relocations present. 681 * 682 * User need to audit the code to make sure 683 * some symbols which should have been section 684 * relative have not become absolute because of some 685 * linker optimization or wrong programming usage. 686 * 687 * Before warning check if this absolute symbol 688 * relocation is harmless. 689 */ 690 if (is_reloc(S_ABS, name) || is_reloc(S_REL, name)) 691 continue; 692 693 if (!printed) { 694 printf("WARNING: Absolute relocations" 695 " present\n"); 696 printf("Offset Info Type Sym.Value " 697 "Sym.Name\n"); 698 printed = 1; 699 } 700 701 printf(format, 702 rel->r_offset, 703 rel->r_info, 704 rel_type(ELF_R_TYPE(rel->r_info)), 705 sym->st_value, 706 name); 707 } 708 } 709 710 if (printed) 711 printf("\n"); 712} 713 714static void add_reloc(struct relocs *r, uint32_t offset) 715{ 716 if (r->count == r->size) { 717 unsigned long newsize = r->size + 50000; 718 void *mem = realloc(r->offset, newsize * sizeof(r->offset[0])); 719 720 if (!mem) 721 die("realloc of %ld entries for relocs failed\n", 722 newsize); 723 r->offset = mem; 724 r->size = newsize; 725 } 726 r->offset[r->count++] = offset; 727} 728 729static void walk_relocs(int (*process)(struct section *sec, Elf_Rel *rel, 730 Elf_Sym *sym, const char *symname)) 731{ 732 int i; 733 /* Walk through the relocations */ 734 for (i = 0; i < shnum; i++) { 735 char *sym_strtab; 736 Elf_Sym *sh_symtab; 737 struct section *sec_applies, *sec_symtab; 738 int j; 739 struct section *sec = &secs[i]; 740 741 if (sec->shdr.sh_type != SHT_REL_TYPE) { 742 continue; 743 } 744 sec_symtab = sec->link; 745 sec_applies = &secs[sec->shdr.sh_info]; 746 if (!(sec_applies->shdr.sh_flags & SHF_ALLOC)) { 747 continue; 748 } 749 sh_symtab = sec_symtab->symtab; 750 sym_strtab = sec_symtab->link->strtab; 751 for (j = 0; j < sec->shdr.sh_size/sizeof(Elf_Rel); j++) { 752 Elf_Rel *rel = &sec->reltab[j]; 753 Elf_Sym *sym = &sh_symtab[ELF_R_SYM(rel->r_info)]; 754 const char *symname = sym_name(sym_strtab, sym); 755 756 process(sec, rel, sym, symname); 757 } 758 } 759} 760 761/* 762 * The .data..percpu section is a special case for x86_64 SMP kernels. 763 * It is used to initialize the actual per_cpu areas and to provide 764 * definitions for the per_cpu variables that correspond to their offsets 765 * within the percpu area. Since the values of all of the symbols need 766 * to be offsets from the start of the per_cpu area the virtual address 767 * (sh_addr) of .data..percpu is 0 in SMP kernels. 768 * 769 * This means that: 770 * 771 * Relocations that reference symbols in the per_cpu area do not 772 * need further relocation (since the value is an offset relative 773 * to the start of the per_cpu area that does not change). 774 * 775 * Relocations that apply to the per_cpu area need to have their 776 * offset adjusted by by the value of __per_cpu_load to make them 777 * point to the correct place in the loaded image (because the 778 * virtual address of .data..percpu is 0). 779 * 780 * For non SMP kernels .data..percpu is linked as part of the normal 781 * kernel data and does not require special treatment. 782 * 783 */ 784static int per_cpu_shndx = -1; 785static Elf_Addr per_cpu_load_addr; 786 787static void percpu_init(void) 788{ 789 int i; 790 for (i = 0; i < shnum; i++) { 791 ElfW(Sym) *sym; 792 if (strcmp(sec_name(i), ".data..percpu")) 793 continue; 794 795 if (secs[i].shdr.sh_addr != 0) /* non SMP kernel */ 796 return; 797 798 sym = sym_lookup("__per_cpu_load"); 799 if (!sym) 800 die("can't find __per_cpu_load\n"); 801 802 per_cpu_shndx = i; 803 per_cpu_load_addr = sym->st_value; 804 return; 805 } 806} 807 808#if ELF_BITS == 64 809 810/* 811 * Check to see if a symbol lies in the .data..percpu section. 812 * 813 * The linker incorrectly associates some symbols with the 814 * .data..percpu section so we also need to check the symbol 815 * name to make sure that we classify the symbol correctly. 816 * 817 * The GNU linker incorrectly associates: 818 * __init_begin 819 * __per_cpu_load 820 * 821 * The "gold" linker incorrectly associates: 822 * init_per_cpu__fixed_percpu_data 823 * init_per_cpu__gdt_page 824 */ 825static int is_percpu_sym(ElfW(Sym) *sym, const char *symname) 826{ 827 int shndx = sym_index(sym); 828 829 return (shndx == per_cpu_shndx) && 830 strcmp(symname, "__init_begin") && 831 strcmp(symname, "__per_cpu_load") && 832 strncmp(symname, "init_per_cpu_", 13); 833} 834 835 836static int do_reloc64(struct section *sec, Elf_Rel *rel, ElfW(Sym) *sym, 837 const char *symname) 838{ 839 unsigned r_type = ELF64_R_TYPE(rel->r_info); 840 ElfW(Addr) offset = rel->r_offset; 841 int shn_abs = (sym->st_shndx == SHN_ABS) && !is_reloc(S_REL, symname); 842 843 if (sym->st_shndx == SHN_UNDEF) 844 return 0; 845 846 /* 847 * Adjust the offset if this reloc applies to the percpu section. 848 */ 849 if (sec->shdr.sh_info == per_cpu_shndx) 850 offset += per_cpu_load_addr; 851 852 switch (r_type) { 853 case R_X86_64_NONE: 854 /* NONE can be ignored. */ 855 break; 856 857 case R_X86_64_PC32: 858 case R_X86_64_PLT32: 859 /* 860 * PC relative relocations don't need to be adjusted unless 861 * referencing a percpu symbol. 862 * 863 * NB: R_X86_64_PLT32 can be treated as R_X86_64_PC32. 864 */ 865 if (is_percpu_sym(sym, symname)) 866 add_reloc(&relocs32neg, offset); 867 break; 868 869 case R_X86_64_PC64: 870 /* 871 * Only used by jump labels 872 */ 873 if (is_percpu_sym(sym, symname)) 874 die("Invalid R_X86_64_PC64 relocation against per-CPU symbol %s\n", 875 symname); 876 break; 877 878 case R_X86_64_32: 879 case R_X86_64_32S: 880 case R_X86_64_64: 881 /* 882 * References to the percpu area don't need to be adjusted. 883 */ 884 if (is_percpu_sym(sym, symname)) 885 break; 886 887 if (shn_abs) { 888 /* 889 * Whitelisted absolute symbols do not require 890 * relocation. 891 */ 892 if (is_reloc(S_ABS, symname)) 893 break; 894 895 die("Invalid absolute %s relocation: %s\n", 896 rel_type(r_type), symname); 897 break; 898 } 899 900 /* 901 * Relocation offsets for 64 bit kernels are output 902 * as 32 bits and sign extended back to 64 bits when 903 * the relocations are processed. 904 * Make sure that the offset will fit. 905 */ 906 if ((int32_t)offset != (int64_t)offset) 907 die("Relocation offset doesn't fit in 32 bits\n"); 908 909 if (r_type == R_X86_64_64) 910 add_reloc(&relocs64, offset); 911 else 912 add_reloc(&relocs32, offset); 913 break; 914 915 default: 916 die("Unsupported relocation type: %s (%d)\n", 917 rel_type(r_type), r_type); 918 break; 919 } 920 921 return 0; 922} 923 924#else 925 926static int do_reloc32(struct section *sec, Elf_Rel *rel, Elf_Sym *sym, 927 const char *symname) 928{ 929 unsigned r_type = ELF32_R_TYPE(rel->r_info); 930 int shn_abs = (sym->st_shndx == SHN_ABS) && !is_reloc(S_REL, symname); 931 932 switch (r_type) { 933 case R_386_NONE: 934 case R_386_PC32: 935 case R_386_PC16: 936 case R_386_PC8: 937 case R_386_PLT32: 938 /* 939 * NONE can be ignored and PC relative relocations don't need 940 * to be adjusted. Because sym must be defined, R_386_PLT32 can 941 * be treated the same way as R_386_PC32. 942 */ 943 break; 944 945 case R_386_32: 946 if (shn_abs) { 947 /* 948 * Whitelisted absolute symbols do not require 949 * relocation. 950 */ 951 if (is_reloc(S_ABS, symname)) 952 break; 953 954 die("Invalid absolute %s relocation: %s\n", 955 rel_type(r_type), symname); 956 break; 957 } 958 959 add_reloc(&relocs32, rel->r_offset); 960 break; 961 962 default: 963 die("Unsupported relocation type: %s (%d)\n", 964 rel_type(r_type), r_type); 965 break; 966 } 967 968 return 0; 969} 970 971static int do_reloc_real(struct section *sec, Elf_Rel *rel, Elf_Sym *sym, 972 const char *symname) 973{ 974 unsigned r_type = ELF32_R_TYPE(rel->r_info); 975 int shn_abs = (sym->st_shndx == SHN_ABS) && !is_reloc(S_REL, symname); 976 977 switch (r_type) { 978 case R_386_NONE: 979 case R_386_PC32: 980 case R_386_PC16: 981 case R_386_PC8: 982 case R_386_PLT32: 983 /* 984 * NONE can be ignored and PC relative relocations don't need 985 * to be adjusted. Because sym must be defined, R_386_PLT32 can 986 * be treated the same way as R_386_PC32. 987 */ 988 break; 989 990 case R_386_16: 991 if (shn_abs) { 992 /* 993 * Whitelisted absolute symbols do not require 994 * relocation. 995 */ 996 if (is_reloc(S_ABS, symname)) 997 break; 998 999 if (is_reloc(S_SEG, symname)) { 1000 add_reloc(&relocs16, rel->r_offset); 1001 break; 1002 } 1003 } else { 1004 if (!is_reloc(S_LIN, symname)) 1005 break; 1006 } 1007 die("Invalid %s %s relocation: %s\n", 1008 shn_abs ? "absolute" : "relative", 1009 rel_type(r_type), symname); 1010 break; 1011 1012 case R_386_32: 1013 if (shn_abs) { 1014 /* 1015 * Whitelisted absolute symbols do not require 1016 * relocation. 1017 */ 1018 if (is_reloc(S_ABS, symname)) 1019 break; 1020 1021 if (is_reloc(S_REL, symname)) { 1022 add_reloc(&relocs32, rel->r_offset); 1023 break; 1024 } 1025 } else { 1026 if (is_reloc(S_LIN, symname)) 1027 add_reloc(&relocs32, rel->r_offset); 1028 break; 1029 } 1030 die("Invalid %s %s relocation: %s\n", 1031 shn_abs ? "absolute" : "relative", 1032 rel_type(r_type), symname); 1033 break; 1034 1035 default: 1036 die("Unsupported relocation type: %s (%d)\n", 1037 rel_type(r_type), r_type); 1038 break; 1039 } 1040 1041 return 0; 1042} 1043 1044#endif 1045 1046static int cmp_relocs(const void *va, const void *vb) 1047{ 1048 const uint32_t *a, *b; 1049 a = va; b = vb; 1050 return (*a == *b)? 0 : (*a > *b)? 1 : -1; 1051} 1052 1053static void sort_relocs(struct relocs *r) 1054{ 1055 qsort(r->offset, r->count, sizeof(r->offset[0]), cmp_relocs); 1056} 1057 1058static int write32(uint32_t v, FILE *f) 1059{ 1060 unsigned char buf[4]; 1061 1062 put_unaligned_le32(v, buf); 1063 return fwrite(buf, 1, 4, f) == 4 ? 0 : -1; 1064} 1065 1066static int write32_as_text(uint32_t v, FILE *f) 1067{ 1068 return fprintf(f, "\t.long 0x%08"PRIx32"\n", v) > 0 ? 0 : -1; 1069} 1070 1071static void emit_relocs(int as_text, int use_real_mode) 1072{ 1073 int i; 1074 int (*write_reloc)(uint32_t, FILE *) = write32; 1075 int (*do_reloc)(struct section *sec, Elf_Rel *rel, Elf_Sym *sym, 1076 const char *symname); 1077 1078#if ELF_BITS == 64 1079 if (!use_real_mode) 1080 do_reloc = do_reloc64; 1081 else 1082 die("--realmode not valid for a 64-bit ELF file"); 1083#else 1084 if (!use_real_mode) 1085 do_reloc = do_reloc32; 1086 else 1087 do_reloc = do_reloc_real; 1088#endif 1089 1090 /* Collect up the relocations */ 1091 walk_relocs(do_reloc); 1092 1093 if (relocs16.count && !use_real_mode) 1094 die("Segment relocations found but --realmode not specified\n"); 1095 1096 /* Order the relocations for more efficient processing */ 1097 sort_relocs(&relocs32); 1098#if ELF_BITS == 64 1099 sort_relocs(&relocs32neg); 1100 sort_relocs(&relocs64); 1101#else 1102 sort_relocs(&relocs16); 1103#endif 1104 1105 /* Print the relocations */ 1106 if (as_text) { 1107 /* Print the relocations in a form suitable that 1108 * gas will like. 1109 */ 1110 printf(".section \".data.reloc\",\"a\"\n"); 1111 printf(".balign 4\n"); 1112 write_reloc = write32_as_text; 1113 } 1114 1115 if (use_real_mode) { 1116 write_reloc(relocs16.count, stdout); 1117 for (i = 0; i < relocs16.count; i++) 1118 write_reloc(relocs16.offset[i], stdout); 1119 1120 write_reloc(relocs32.count, stdout); 1121 for (i = 0; i < relocs32.count; i++) 1122 write_reloc(relocs32.offset[i], stdout); 1123 } else { 1124#if ELF_BITS == 64 1125 /* Print a stop */ 1126 write_reloc(0, stdout); 1127 1128 /* Now print each relocation */ 1129 for (i = 0; i < relocs64.count; i++) 1130 write_reloc(relocs64.offset[i], stdout); 1131 1132 /* Print a stop */ 1133 write_reloc(0, stdout); 1134 1135 /* Now print each inverse 32-bit relocation */ 1136 for (i = 0; i < relocs32neg.count; i++) 1137 write_reloc(relocs32neg.offset[i], stdout); 1138#endif 1139 1140 /* Print a stop */ 1141 write_reloc(0, stdout); 1142 1143 /* Now print each relocation */ 1144 for (i = 0; i < relocs32.count; i++) 1145 write_reloc(relocs32.offset[i], stdout); 1146 } 1147} 1148 1149/* 1150 * As an aid to debugging problems with different linkers 1151 * print summary information about the relocs. 1152 * Since different linkers tend to emit the sections in 1153 * different orders we use the section names in the output. 1154 */ 1155static int do_reloc_info(struct section *sec, Elf_Rel *rel, ElfW(Sym) *sym, 1156 const char *symname) 1157{ 1158 printf("%s\t%s\t%s\t%s\n", 1159 sec_name(sec->shdr.sh_info), 1160 rel_type(ELF_R_TYPE(rel->r_info)), 1161 symname, 1162 sec_name(sym_index(sym))); 1163 return 0; 1164} 1165 1166static void print_reloc_info(void) 1167{ 1168 printf("reloc section\treloc type\tsymbol\tsymbol section\n"); 1169 walk_relocs(do_reloc_info); 1170} 1171 1172#if ELF_BITS == 64 1173# define process process_64 1174#else 1175# define process process_32 1176#endif 1177 1178void process(FILE *fp, int use_real_mode, int as_text, 1179 int show_absolute_syms, int show_absolute_relocs, 1180 int show_reloc_info) 1181{ 1182 regex_init(use_real_mode); 1183 read_ehdr(fp); 1184 read_shdrs(fp); 1185 read_strtabs(fp); 1186 read_symtabs(fp); 1187 read_relocs(fp); 1188 if (ELF_BITS == 64) 1189 percpu_init(); 1190 if (show_absolute_syms) { 1191 print_absolute_symbols(); 1192 return; 1193 } 1194 if (show_absolute_relocs) { 1195 print_absolute_relocs(); 1196 return; 1197 } 1198 if (show_reloc_info) { 1199 print_reloc_info(); 1200 return; 1201 } 1202 emit_relocs(as_text, use_real_mode); 1203} 1204