1/* Postprocess module symbol versions 2 * 3 * Copyright 2003 Kai Germaschewski 4 * Copyright 2002-2004 Rusty Russell, IBM Corporation 5 * Copyright 2006-2008 Sam Ravnborg 6 * Based in part on module-init-tools/depmod.c,file2alias 7 * 8 * This software may be used and distributed according to the terms 9 * of the GNU General Public License, incorporated herein by reference. 10 * 11 * Usage: modpost vmlinux module1.o module2.o ... 12 */ 13 14#define _GNU_SOURCE 15#include <elf.h> 16#include <stdio.h> 17#include <ctype.h> 18#include <string.h> 19#include <limits.h> 20#include <stdbool.h> 21#include <errno.h> 22#include "modpost.h" 23#include "../../include/linux/license.h" 24 25/* Are we using CONFIG_MODVERSIONS? */ 26static int modversions = 0; 27/* Warn about undefined symbols? (do so if we have vmlinux) */ 28static int have_vmlinux = 0; 29/* Is CONFIG_MODULE_SRCVERSION_ALL set? */ 30static int all_versions = 0; 31/* If we are modposting external module set to 1 */ 32static int external_module = 0; 33/* Only warn about unresolved symbols */ 34static int warn_unresolved = 0; 35/* How a symbol is exported */ 36static int sec_mismatch_count = 0; 37static int sec_mismatch_fatal = 0; 38/* ignore missing files */ 39static int ignore_missing_files; 40/* If set to 1, only warn (instead of error) about missing ns imports */ 41static int allow_missing_ns_imports; 42 43enum export { 44 export_plain, export_unused, export_gpl, 45 export_unused_gpl, export_gpl_future, export_unknown 46}; 47 48/* In kernel, this size is defined in linux/module.h; 49 * here we use Elf_Addr instead of long for covering cross-compile 50 */ 51 52#define MODULE_NAME_LEN (64 - sizeof(Elf_Addr)) 53 54void __attribute__((format(printf, 2, 3))) 55modpost_log(enum loglevel loglevel, const char *fmt, ...) 56{ 57 va_list arglist; 58 59 switch (loglevel) { 60 case LOG_WARN: 61 fprintf(stderr, "WARNING: "); 62 break; 63 case LOG_ERROR: 64 fprintf(stderr, "ERROR: "); 65 break; 66 case LOG_FATAL: 67 fprintf(stderr, "FATAL: "); 68 break; 69 default: /* invalid loglevel, ignore */ 70 break; 71 } 72 73 fprintf(stderr, "modpost: "); 74 75 va_start(arglist, fmt); 76 vfprintf(stderr, fmt, arglist); 77 va_end(arglist); 78 79 if (loglevel == LOG_FATAL) 80 exit(1); 81} 82 83void *do_nofail(void *ptr, const char *expr) 84{ 85 if (!ptr) 86 fatal("Memory allocation failure: %s.\n", expr); 87 88 return ptr; 89} 90 91char *read_text_file(const char *filename) 92{ 93 struct stat st; 94 size_t nbytes; 95 int fd; 96 char *buf; 97 98 fd = open(filename, O_RDONLY); 99 if (fd < 0) { 100 perror(filename); 101 exit(1); 102 } 103 104 if (fstat(fd, &st) < 0) { 105 perror(filename); 106 exit(1); 107 } 108 109 buf = NOFAIL(malloc(st.st_size + 1)); 110 111 nbytes = st.st_size; 112 113 while (nbytes) { 114 ssize_t bytes_read; 115 116 bytes_read = read(fd, buf, nbytes); 117 if (bytes_read < 0) { 118 perror(filename); 119 exit(1); 120 } 121 122 nbytes -= bytes_read; 123 } 124 buf[st.st_size] = '\0'; 125 126 close(fd); 127 128 return buf; 129} 130 131char *get_line(char **stringp) 132{ 133 char *orig = *stringp, *next; 134 135 /* do not return the unwanted extra line at EOF */ 136 if (!orig || *orig == '\0') 137 return NULL; 138 139 /* don't use strsep here, it is not available everywhere */ 140 next = strchr(orig, '\n'); 141 if (next) 142 *next++ = '\0'; 143 144 *stringp = next; 145 146 return orig; 147} 148 149/* A list of all modules we processed */ 150static struct module *modules; 151 152static struct module *find_module(const char *modname) 153{ 154 struct module *mod; 155 156 for (mod = modules; mod; mod = mod->next) 157 if (strcmp(mod->name, modname) == 0) 158 break; 159 return mod; 160} 161 162static struct module *new_module(const char *modname) 163{ 164 struct module *mod; 165 166 mod = NOFAIL(malloc(sizeof(*mod) + strlen(modname) + 1)); 167 memset(mod, 0, sizeof(*mod)); 168 169 /* add to list */ 170 strcpy(mod->name, modname); 171 mod->is_vmlinux = (strcmp(modname, "vmlinux") == 0); 172 mod->gpl_compatible = -1; 173 mod->next = modules; 174 modules = mod; 175 176 if (mod->is_vmlinux) 177 have_vmlinux = 1; 178 179 return mod; 180} 181 182/* A hash of all exported symbols, 183 * struct symbol is also used for lists of unresolved symbols */ 184 185#define SYMBOL_HASH_SIZE 1024 186 187struct symbol { 188 struct symbol *next; 189 struct module *module; 190 unsigned int crc; 191 int crc_valid; 192 char *namespace; 193 unsigned int weak:1; 194 unsigned int is_static:1; /* 1 if symbol is not global */ 195 enum export export; /* Type of export */ 196 char name[]; 197}; 198 199static struct symbol *symbolhash[SYMBOL_HASH_SIZE]; 200 201/* This is based on the hash agorithm from gdbm, via tdb */ 202static inline unsigned int tdb_hash(const char *name) 203{ 204 unsigned value; /* Used to compute the hash value. */ 205 unsigned i; /* Used to cycle through random values. */ 206 207 /* Set the initial value from the key size. */ 208 for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++) 209 value = (value + (((unsigned char *)name)[i] << (i*5 % 24))); 210 211 return (1103515243 * value + 12345); 212} 213 214/** 215 * Allocate a new symbols for use in the hash of exported symbols or 216 * the list of unresolved symbols per module 217 **/ 218static struct symbol *alloc_symbol(const char *name, unsigned int weak, 219 struct symbol *next) 220{ 221 struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1)); 222 223 memset(s, 0, sizeof(*s)); 224 strcpy(s->name, name); 225 s->weak = weak; 226 s->next = next; 227 s->is_static = 1; 228 return s; 229} 230 231/* For the hash of exported symbols */ 232static struct symbol *new_symbol(const char *name, struct module *module, 233 enum export export) 234{ 235 unsigned int hash; 236 237 hash = tdb_hash(name) % SYMBOL_HASH_SIZE; 238 symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]); 239 240 return symbolhash[hash]; 241} 242 243static struct symbol *find_symbol(const char *name) 244{ 245 struct symbol *s; 246 247 /* For our purposes, .foo matches foo. PPC64 needs this. */ 248 if (name[0] == '.') 249 name++; 250 251 for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) { 252 if (strcmp(s->name, name) == 0) 253 return s; 254 } 255 return NULL; 256} 257 258static bool contains_namespace(struct namespace_list *list, 259 const char *namespace) 260{ 261 for (; list; list = list->next) 262 if (!strcmp(list->namespace, namespace)) 263 return true; 264 265 return false; 266} 267 268static void add_namespace(struct namespace_list **list, const char *namespace) 269{ 270 struct namespace_list *ns_entry; 271 272 if (!contains_namespace(*list, namespace)) { 273 ns_entry = NOFAIL(malloc(sizeof(struct namespace_list) + 274 strlen(namespace) + 1)); 275 strcpy(ns_entry->namespace, namespace); 276 ns_entry->next = *list; 277 *list = ns_entry; 278 } 279} 280 281static bool module_imports_namespace(struct module *module, 282 const char *namespace) 283{ 284 return contains_namespace(module->imported_namespaces, namespace); 285} 286 287static const struct { 288 const char *str; 289 enum export export; 290} export_list[] = { 291 { .str = "EXPORT_SYMBOL", .export = export_plain }, 292 { .str = "EXPORT_UNUSED_SYMBOL", .export = export_unused }, 293 { .str = "EXPORT_SYMBOL_GPL", .export = export_gpl }, 294 { .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl }, 295 { .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future }, 296 { .str = "(unknown)", .export = export_unknown }, 297}; 298 299 300static const char *export_str(enum export ex) 301{ 302 return export_list[ex].str; 303} 304 305static enum export export_no(const char *s) 306{ 307 int i; 308 309 if (!s) 310 return export_unknown; 311 for (i = 0; export_list[i].export != export_unknown; i++) { 312 if (strcmp(export_list[i].str, s) == 0) 313 return export_list[i].export; 314 } 315 return export_unknown; 316} 317 318static void *sym_get_data_by_offset(const struct elf_info *info, 319 unsigned int secindex, unsigned long offset) 320{ 321 Elf_Shdr *sechdr = &info->sechdrs[secindex]; 322 323 if (info->hdr->e_type != ET_REL) 324 offset -= sechdr->sh_addr; 325 326 return (void *)info->hdr + sechdr->sh_offset + offset; 327} 328 329static void *sym_get_data(const struct elf_info *info, const Elf_Sym *sym) 330{ 331 return sym_get_data_by_offset(info, get_secindex(info, sym), 332 sym->st_value); 333} 334 335static const char *sech_name(const struct elf_info *info, Elf_Shdr *sechdr) 336{ 337 return sym_get_data_by_offset(info, info->secindex_strings, 338 sechdr->sh_name); 339} 340 341static const char *sec_name(const struct elf_info *info, int secindex) 342{ 343 return sech_name(info, &info->sechdrs[secindex]); 344} 345 346#define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0) 347 348static enum export export_from_secname(struct elf_info *elf, unsigned int sec) 349{ 350 const char *secname = sec_name(elf, sec); 351 352 if (strstarts(secname, "___ksymtab+")) 353 return export_plain; 354 else if (strstarts(secname, "___ksymtab_unused+")) 355 return export_unused; 356 else if (strstarts(secname, "___ksymtab_gpl+")) 357 return export_gpl; 358 else if (strstarts(secname, "___ksymtab_unused_gpl+")) 359 return export_unused_gpl; 360 else if (strstarts(secname, "___ksymtab_gpl_future+")) 361 return export_gpl_future; 362 else 363 return export_unknown; 364} 365 366static enum export export_from_sec(struct elf_info *elf, unsigned int sec) 367{ 368 if (sec == elf->export_sec) 369 return export_plain; 370 else if (sec == elf->export_unused_sec) 371 return export_unused; 372 else if (sec == elf->export_gpl_sec) 373 return export_gpl; 374 else if (sec == elf->export_unused_gpl_sec) 375 return export_unused_gpl; 376 else if (sec == elf->export_gpl_future_sec) 377 return export_gpl_future; 378 else 379 return export_unknown; 380} 381 382static const char *namespace_from_kstrtabns(const struct elf_info *info, 383 const Elf_Sym *sym) 384{ 385 const char *value = sym_get_data(info, sym); 386 return value[0] ? value : NULL; 387} 388 389static void sym_update_namespace(const char *symname, const char *namespace) 390{ 391 struct symbol *s = find_symbol(symname); 392 393 /* 394 * That symbol should have been created earlier and thus this is 395 * actually an assertion. 396 */ 397 if (!s) { 398 merror("Could not update namespace(%s) for symbol %s\n", 399 namespace, symname); 400 return; 401 } 402 403 free(s->namespace); 404 s->namespace = 405 namespace && namespace[0] ? NOFAIL(strdup(namespace)) : NULL; 406} 407 408/** 409 * Add an exported symbol - it may have already been added without a 410 * CRC, in this case just update the CRC 411 **/ 412static struct symbol *sym_add_exported(const char *name, struct module *mod, 413 enum export export) 414{ 415 struct symbol *s = find_symbol(name); 416 417 if (!s) { 418 s = new_symbol(name, mod, export); 419 } else if (!external_module || s->module->is_vmlinux || 420 s->module == mod) { 421 warn("%s: '%s' exported twice. Previous export was in %s%s\n", 422 mod->name, name, s->module->name, 423 s->module->is_vmlinux ? "" : ".ko"); 424 return s; 425 } 426 427 s->module = mod; 428 s->export = export; 429 return s; 430} 431 432static void sym_set_crc(const char *name, unsigned int crc) 433{ 434 struct symbol *s = find_symbol(name); 435 436 /* 437 * Ignore stand-alone __crc_*, which might be auto-generated symbols 438 * such as __*_veneer in ARM ELF. 439 */ 440 if (!s) 441 return; 442 443 s->crc = crc; 444 s->crc_valid = 1; 445} 446 447static void *grab_file(const char *filename, size_t *size) 448{ 449 struct stat st; 450 void *map = MAP_FAILED; 451 int fd; 452 453 fd = open(filename, O_RDONLY); 454 if (fd < 0) 455 return NULL; 456 if (fstat(fd, &st)) 457 goto failed; 458 459 *size = st.st_size; 460 map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0); 461 462failed: 463 close(fd); 464 if (map == MAP_FAILED) 465 return NULL; 466 return map; 467} 468 469static void release_file(void *file, size_t size) 470{ 471 munmap(file, size); 472} 473 474static int parse_elf(struct elf_info *info, const char *filename) 475{ 476 unsigned int i; 477 Elf_Ehdr *hdr; 478 Elf_Shdr *sechdrs; 479 Elf_Sym *sym; 480 const char *secstrings; 481 unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U; 482 483 hdr = grab_file(filename, &info->size); 484 if (!hdr) { 485 if (ignore_missing_files) { 486 fprintf(stderr, "%s: %s (ignored)\n", filename, 487 strerror(errno)); 488 return 0; 489 } 490 perror(filename); 491 exit(1); 492 } 493 info->hdr = hdr; 494 if (info->size < sizeof(*hdr)) { 495 /* file too small, assume this is an empty .o file */ 496 return 0; 497 } 498 /* Is this a valid ELF file? */ 499 if ((hdr->e_ident[EI_MAG0] != ELFMAG0) || 500 (hdr->e_ident[EI_MAG1] != ELFMAG1) || 501 (hdr->e_ident[EI_MAG2] != ELFMAG2) || 502 (hdr->e_ident[EI_MAG3] != ELFMAG3)) { 503 /* Not an ELF file - silently ignore it */ 504 return 0; 505 } 506 /* Fix endianness in ELF header */ 507 hdr->e_type = TO_NATIVE(hdr->e_type); 508 hdr->e_machine = TO_NATIVE(hdr->e_machine); 509 hdr->e_version = TO_NATIVE(hdr->e_version); 510 hdr->e_entry = TO_NATIVE(hdr->e_entry); 511 hdr->e_phoff = TO_NATIVE(hdr->e_phoff); 512 hdr->e_shoff = TO_NATIVE(hdr->e_shoff); 513 hdr->e_flags = TO_NATIVE(hdr->e_flags); 514 hdr->e_ehsize = TO_NATIVE(hdr->e_ehsize); 515 hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize); 516 hdr->e_phnum = TO_NATIVE(hdr->e_phnum); 517 hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize); 518 hdr->e_shnum = TO_NATIVE(hdr->e_shnum); 519 hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx); 520 sechdrs = (void *)hdr + hdr->e_shoff; 521 info->sechdrs = sechdrs; 522 523 /* Check if file offset is correct */ 524 if (hdr->e_shoff > info->size) { 525 fatal("section header offset=%lu in file '%s' is bigger than filesize=%zu\n", 526 (unsigned long)hdr->e_shoff, filename, info->size); 527 return 0; 528 } 529 530 if (hdr->e_shnum == SHN_UNDEF) { 531 /* 532 * There are more than 64k sections, 533 * read count from .sh_size. 534 */ 535 info->num_sections = TO_NATIVE(sechdrs[0].sh_size); 536 } 537 else { 538 info->num_sections = hdr->e_shnum; 539 } 540 if (hdr->e_shstrndx == SHN_XINDEX) { 541 info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link); 542 } 543 else { 544 info->secindex_strings = hdr->e_shstrndx; 545 } 546 547 /* Fix endianness in section headers */ 548 for (i = 0; i < info->num_sections; i++) { 549 sechdrs[i].sh_name = TO_NATIVE(sechdrs[i].sh_name); 550 sechdrs[i].sh_type = TO_NATIVE(sechdrs[i].sh_type); 551 sechdrs[i].sh_flags = TO_NATIVE(sechdrs[i].sh_flags); 552 sechdrs[i].sh_addr = TO_NATIVE(sechdrs[i].sh_addr); 553 sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset); 554 sechdrs[i].sh_size = TO_NATIVE(sechdrs[i].sh_size); 555 sechdrs[i].sh_link = TO_NATIVE(sechdrs[i].sh_link); 556 sechdrs[i].sh_info = TO_NATIVE(sechdrs[i].sh_info); 557 sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign); 558 sechdrs[i].sh_entsize = TO_NATIVE(sechdrs[i].sh_entsize); 559 } 560 /* Find symbol table. */ 561 secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset; 562 for (i = 1; i < info->num_sections; i++) { 563 const char *secname; 564 int nobits = sechdrs[i].sh_type == SHT_NOBITS; 565 566 if (!nobits && sechdrs[i].sh_offset > info->size) { 567 fatal("%s is truncated. sechdrs[i].sh_offset=%lu > " 568 "sizeof(*hrd)=%zu\n", filename, 569 (unsigned long)sechdrs[i].sh_offset, 570 sizeof(*hdr)); 571 return 0; 572 } 573 secname = secstrings + sechdrs[i].sh_name; 574 if (strcmp(secname, ".modinfo") == 0) { 575 if (nobits) 576 fatal("%s has NOBITS .modinfo\n", filename); 577 info->modinfo = (void *)hdr + sechdrs[i].sh_offset; 578 info->modinfo_len = sechdrs[i].sh_size; 579 } else if (strcmp(secname, "__ksymtab") == 0) 580 info->export_sec = i; 581 else if (strcmp(secname, "__ksymtab_unused") == 0) 582 info->export_unused_sec = i; 583 else if (strcmp(secname, "__ksymtab_gpl") == 0) 584 info->export_gpl_sec = i; 585 else if (strcmp(secname, "__ksymtab_unused_gpl") == 0) 586 info->export_unused_gpl_sec = i; 587 else if (strcmp(secname, "__ksymtab_gpl_future") == 0) 588 info->export_gpl_future_sec = i; 589 590 if (sechdrs[i].sh_type == SHT_SYMTAB) { 591 unsigned int sh_link_idx; 592 symtab_idx = i; 593 info->symtab_start = (void *)hdr + 594 sechdrs[i].sh_offset; 595 info->symtab_stop = (void *)hdr + 596 sechdrs[i].sh_offset + sechdrs[i].sh_size; 597 sh_link_idx = sechdrs[i].sh_link; 598 info->strtab = (void *)hdr + 599 sechdrs[sh_link_idx].sh_offset; 600 } 601 602 /* 32bit section no. table? ("more than 64k sections") */ 603 if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) { 604 symtab_shndx_idx = i; 605 info->symtab_shndx_start = (void *)hdr + 606 sechdrs[i].sh_offset; 607 info->symtab_shndx_stop = (void *)hdr + 608 sechdrs[i].sh_offset + sechdrs[i].sh_size; 609 } 610 } 611 if (!info->symtab_start) 612 fatal("%s has no symtab?\n", filename); 613 614 /* Fix endianness in symbols */ 615 for (sym = info->symtab_start; sym < info->symtab_stop; sym++) { 616 sym->st_shndx = TO_NATIVE(sym->st_shndx); 617 sym->st_name = TO_NATIVE(sym->st_name); 618 sym->st_value = TO_NATIVE(sym->st_value); 619 sym->st_size = TO_NATIVE(sym->st_size); 620 } 621 622 if (symtab_shndx_idx != ~0U) { 623 Elf32_Word *p; 624 if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link) 625 fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n", 626 filename, sechdrs[symtab_shndx_idx].sh_link, 627 symtab_idx); 628 /* Fix endianness */ 629 for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop; 630 p++) 631 *p = TO_NATIVE(*p); 632 } 633 634 return 1; 635} 636 637static void parse_elf_finish(struct elf_info *info) 638{ 639 release_file(info->hdr, info->size); 640} 641 642static int ignore_undef_symbol(struct elf_info *info, const char *symname) 643{ 644 /* ignore __this_module, it will be resolved shortly */ 645 if (strcmp(symname, "__this_module") == 0) 646 return 1; 647 /* ignore global offset table */ 648 if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0) 649 return 1; 650 if (info->hdr->e_machine == EM_PPC) 651 /* Special register function linked on all modules during final link of .ko */ 652 if (strstarts(symname, "_restgpr_") || 653 strstarts(symname, "_savegpr_") || 654 strstarts(symname, "_rest32gpr_") || 655 strstarts(symname, "_save32gpr_") || 656 strstarts(symname, "_restvr_") || 657 strstarts(symname, "_savevr_")) 658 return 1; 659 if (info->hdr->e_machine == EM_PPC64) 660 /* Special register function linked on all modules during final link of .ko */ 661 if (strstarts(symname, "_restgpr0_") || 662 strstarts(symname, "_savegpr0_") || 663 strstarts(symname, "_restvr_") || 664 strstarts(symname, "_savevr_") || 665 strcmp(symname, ".TOC.") == 0) 666 return 1; 667 /* Do not ignore this symbol */ 668 return 0; 669} 670 671static void handle_modversion(const struct module *mod, 672 const struct elf_info *info, 673 const Elf_Sym *sym, const char *symname) 674{ 675 unsigned int crc; 676 677 if (sym->st_shndx == SHN_UNDEF) { 678 warn("EXPORT symbol \"%s\" [%s%s] version generation failed, symbol will not be versioned.\n", 679 symname, mod->name, mod->is_vmlinux ? "" : ".ko"); 680 return; 681 } 682 683 if (sym->st_shndx == SHN_ABS) { 684 crc = sym->st_value; 685 } else { 686 unsigned int *crcp; 687 688 /* symbol points to the CRC in the ELF object */ 689 crcp = sym_get_data(info, sym); 690 crc = TO_NATIVE(*crcp); 691 } 692 sym_set_crc(symname, crc); 693} 694 695static void handle_symbol(struct module *mod, struct elf_info *info, 696 const Elf_Sym *sym, const char *symname) 697{ 698 enum export export; 699 const char *name; 700 701 if (strstarts(symname, "__ksymtab")) 702 export = export_from_secname(info, get_secindex(info, sym)); 703 else 704 export = export_from_sec(info, get_secindex(info, sym)); 705 706 switch (sym->st_shndx) { 707 case SHN_COMMON: 708 if (strstarts(symname, "__gnu_lto_")) { 709 /* Should warn here, but modpost runs before the linker */ 710 } else 711 warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name); 712 break; 713 case SHN_UNDEF: 714 /* undefined symbol */ 715 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL && 716 ELF_ST_BIND(sym->st_info) != STB_WEAK) 717 break; 718 if (ignore_undef_symbol(info, symname)) 719 break; 720 if (info->hdr->e_machine == EM_SPARC || 721 info->hdr->e_machine == EM_SPARCV9) { 722 /* Ignore register directives. */ 723 if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER) 724 break; 725 if (symname[0] == '.') { 726 char *munged = NOFAIL(strdup(symname)); 727 munged[0] = '_'; 728 munged[1] = toupper(munged[1]); 729 symname = munged; 730 } 731 } 732 733 mod->unres = alloc_symbol(symname, 734 ELF_ST_BIND(sym->st_info) == STB_WEAK, 735 mod->unres); 736 break; 737 default: 738 /* All exported symbols */ 739 if (strstarts(symname, "__ksymtab_")) { 740 name = symname + strlen("__ksymtab_"); 741 sym_add_exported(name, mod, export); 742 } 743 if (strcmp(symname, "init_module") == 0) 744 mod->has_init = 1; 745 if (strcmp(symname, "cleanup_module") == 0) 746 mod->has_cleanup = 1; 747 break; 748 } 749} 750 751/** 752 * Parse tag=value strings from .modinfo section 753 **/ 754static char *next_string(char *string, unsigned long *secsize) 755{ 756 /* Skip non-zero chars */ 757 while (string[0]) { 758 string++; 759 if ((*secsize)-- <= 1) 760 return NULL; 761 } 762 763 /* Skip any zero padding. */ 764 while (!string[0]) { 765 string++; 766 if ((*secsize)-- <= 1) 767 return NULL; 768 } 769 return string; 770} 771 772static char *get_next_modinfo(struct elf_info *info, const char *tag, 773 char *prev) 774{ 775 char *p; 776 unsigned int taglen = strlen(tag); 777 char *modinfo = info->modinfo; 778 unsigned long size = info->modinfo_len; 779 780 if (prev) { 781 size -= prev - modinfo; 782 modinfo = next_string(prev, &size); 783 } 784 785 for (p = modinfo; p; p = next_string(p, &size)) { 786 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=') 787 return p + taglen + 1; 788 } 789 return NULL; 790} 791 792static char *get_modinfo(struct elf_info *info, const char *tag) 793 794{ 795 return get_next_modinfo(info, tag, NULL); 796} 797 798/** 799 * Test if string s ends in string sub 800 * return 0 if match 801 **/ 802static int strrcmp(const char *s, const char *sub) 803{ 804 int slen, sublen; 805 806 if (!s || !sub) 807 return 1; 808 809 slen = strlen(s); 810 sublen = strlen(sub); 811 812 if ((slen == 0) || (sublen == 0)) 813 return 1; 814 815 if (sublen > slen) 816 return 1; 817 818 return memcmp(s + slen - sublen, sub, sublen); 819} 820 821static const char *sym_name(struct elf_info *elf, Elf_Sym *sym) 822{ 823 if (sym) 824 return elf->strtab + sym->st_name; 825 else 826 return "(unknown)"; 827} 828 829/* The pattern is an array of simple patterns. 830 * "foo" will match an exact string equal to "foo" 831 * "*foo" will match a string that ends with "foo" 832 * "foo*" will match a string that begins with "foo" 833 * "*foo*" will match a string that contains "foo" 834 */ 835static int match(const char *sym, const char * const pat[]) 836{ 837 const char *p; 838 while (*pat) { 839 p = *pat++; 840 const char *endp = p + strlen(p) - 1; 841 842 /* "*foo*" */ 843 if (*p == '*' && *endp == '*') { 844 char *bare = NOFAIL(strndup(p + 1, strlen(p) - 2)); 845 char *here = strstr(sym, bare); 846 847 free(bare); 848 if (here != NULL) 849 return 1; 850 } 851 /* "*foo" */ 852 else if (*p == '*') { 853 if (strrcmp(sym, p + 1) == 0) 854 return 1; 855 } 856 /* "foo*" */ 857 else if (*endp == '*') { 858 if (strncmp(sym, p, strlen(p) - 1) == 0) 859 return 1; 860 } 861 /* no wildcards */ 862 else { 863 if (strcmp(p, sym) == 0) 864 return 1; 865 } 866 } 867 /* no match */ 868 return 0; 869} 870 871/* sections that we do not want to do full section mismatch check on */ 872static const char *const section_white_list[] = 873{ 874 ".comment*", 875 ".debug*", 876 ".cranges", /* sh64 */ 877 ".zdebug*", /* Compressed debug sections. */ 878 ".GCC.command.line", /* record-gcc-switches */ 879 ".mdebug*", /* alpha, score, mips etc. */ 880 ".pdr", /* alpha, score, mips etc. */ 881 ".stab*", 882 ".note*", 883 ".got*", 884 ".toc*", 885 ".xt.prop", /* xtensa */ 886 ".xt.lit", /* xtensa */ 887 ".arcextmap*", /* arc */ 888 ".gnu.linkonce.arcext*", /* arc : modules */ 889 ".cmem*", /* EZchip */ 890 ".fmt_slot*", /* EZchip */ 891 ".gnu.lto*", 892 ".discard.*", 893 NULL 894}; 895 896/* 897 * This is used to find sections missing the SHF_ALLOC flag. 898 * The cause of this is often a section specified in assembler 899 * without "ax" / "aw". 900 */ 901static void check_section(const char *modname, struct elf_info *elf, 902 Elf_Shdr *sechdr) 903{ 904 const char *sec = sech_name(elf, sechdr); 905 906 if (sechdr->sh_type == SHT_PROGBITS && 907 !(sechdr->sh_flags & SHF_ALLOC) && 908 !match(sec, section_white_list)) { 909 warn("%s (%s): unexpected non-allocatable section.\n" 910 "Did you forget to use \"ax\"/\"aw\" in a .S file?\n" 911 "Note that for example <linux/init.h> contains\n" 912 "section definitions for use in .S files.\n\n", 913 modname, sec); 914 } 915} 916 917 918 919#define ALL_INIT_DATA_SECTIONS \ 920 ".init.setup", ".init.rodata", ".meminit.rodata", \ 921 ".init.data", ".meminit.data" 922#define ALL_EXIT_DATA_SECTIONS \ 923 ".exit.data", ".memexit.data" 924 925#define ALL_INIT_TEXT_SECTIONS \ 926 ".init.text", ".meminit.text" 927#define ALL_EXIT_TEXT_SECTIONS \ 928 ".exit.text", ".memexit.text" 929 930#define ALL_PCI_INIT_SECTIONS \ 931 ".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \ 932 ".pci_fixup_enable", ".pci_fixup_resume", \ 933 ".pci_fixup_resume_early", ".pci_fixup_suspend" 934 935#define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS 936#define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS 937 938#define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS 939#define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS 940 941#define DATA_SECTIONS ".data", ".data.rel" 942#define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \ 943 ".kprobes.text", ".cpuidle.text", ".noinstr.text" 944#define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \ 945 ".fixup", ".entry.text", ".exception.text", ".text.*", \ 946 ".coldtext" 947 948#define INIT_SECTIONS ".init.*" 949#define MEM_INIT_SECTIONS ".meminit.*" 950 951#define EXIT_SECTIONS ".exit.*" 952#define MEM_EXIT_SECTIONS ".memexit.*" 953 954#define ALL_TEXT_SECTIONS ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \ 955 TEXT_SECTIONS, OTHER_TEXT_SECTIONS 956 957/* init data sections */ 958static const char *const init_data_sections[] = 959 { ALL_INIT_DATA_SECTIONS, NULL }; 960 961/* all init sections */ 962static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL }; 963 964/* All init and exit sections (code + data) */ 965static const char *const init_exit_sections[] = 966 {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL }; 967 968/* all text sections */ 969static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL }; 970 971/* data section */ 972static const char *const data_sections[] = { DATA_SECTIONS, NULL }; 973 974 975/* symbols in .data that may refer to init/exit sections */ 976#define DEFAULT_SYMBOL_WHITE_LIST \ 977 "*driver", \ 978 "*_template", /* scsi uses *_template a lot */ \ 979 "*_timer", /* arm uses ops structures named _timer a lot */ \ 980 "*_sht", /* scsi also used *_sht to some extent */ \ 981 "*_ops", \ 982 "*_probe", \ 983 "*_probe_one", \ 984 "*_console" 985 986static const char *const head_sections[] = { ".head.text*", NULL }; 987static const char *const linker_symbols[] = 988 { "__init_begin", "_sinittext", "_einittext", NULL }; 989static const char *const optim_symbols[] = { "*.constprop.*", NULL }; 990 991enum mismatch { 992 TEXT_TO_ANY_INIT, 993 DATA_TO_ANY_INIT, 994 TEXT_TO_ANY_EXIT, 995 DATA_TO_ANY_EXIT, 996 XXXINIT_TO_SOME_INIT, 997 XXXEXIT_TO_SOME_EXIT, 998 ANY_INIT_TO_ANY_EXIT, 999 ANY_EXIT_TO_ANY_INIT, 1000 EXPORT_TO_INIT_EXIT, 1001 EXTABLE_TO_NON_TEXT, 1002}; 1003 1004/** 1005 * Describe how to match sections on different criterias: 1006 * 1007 * @fromsec: Array of sections to be matched. 1008 * 1009 * @bad_tosec: Relocations applied to a section in @fromsec to a section in 1010 * this array is forbidden (black-list). Can be empty. 1011 * 1012 * @good_tosec: Relocations applied to a section in @fromsec must be 1013 * targetting sections in this array (white-list). Can be empty. 1014 * 1015 * @mismatch: Type of mismatch. 1016 * 1017 * @symbol_white_list: Do not match a relocation to a symbol in this list 1018 * even if it is targetting a section in @bad_to_sec. 1019 * 1020 * @handler: Specific handler to call when a match is found. If NULL, 1021 * default_mismatch_handler() will be called. 1022 * 1023 */ 1024struct sectioncheck { 1025 const char *fromsec[20]; 1026 const char *bad_tosec[20]; 1027 const char *good_tosec[20]; 1028 enum mismatch mismatch; 1029 const char *symbol_white_list[20]; 1030 void (*handler)(const char *modname, struct elf_info *elf, 1031 const struct sectioncheck* const mismatch, 1032 Elf_Rela *r, Elf_Sym *sym, const char *fromsec); 1033 1034}; 1035 1036static void extable_mismatch_handler(const char *modname, struct elf_info *elf, 1037 const struct sectioncheck* const mismatch, 1038 Elf_Rela *r, Elf_Sym *sym, 1039 const char *fromsec); 1040 1041static const struct sectioncheck sectioncheck[] = { 1042/* Do not reference init/exit code/data from 1043 * normal code and data 1044 */ 1045{ 1046 .fromsec = { TEXT_SECTIONS, NULL }, 1047 .bad_tosec = { ALL_INIT_SECTIONS, NULL }, 1048 .mismatch = TEXT_TO_ANY_INIT, 1049 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 1050}, 1051{ 1052 .fromsec = { DATA_SECTIONS, NULL }, 1053 .bad_tosec = { ALL_XXXINIT_SECTIONS, NULL }, 1054 .mismatch = DATA_TO_ANY_INIT, 1055 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 1056}, 1057{ 1058 .fromsec = { DATA_SECTIONS, NULL }, 1059 .bad_tosec = { INIT_SECTIONS, NULL }, 1060 .mismatch = DATA_TO_ANY_INIT, 1061 .symbol_white_list = { 1062 "*_template", "*_timer", "*_sht", "*_ops", 1063 "*_probe", "*_probe_one", "*_console", NULL 1064 }, 1065}, 1066{ 1067 .fromsec = { TEXT_SECTIONS, NULL }, 1068 .bad_tosec = { ALL_EXIT_SECTIONS, NULL }, 1069 .mismatch = TEXT_TO_ANY_EXIT, 1070 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 1071}, 1072{ 1073 .fromsec = { DATA_SECTIONS, NULL }, 1074 .bad_tosec = { ALL_EXIT_SECTIONS, NULL }, 1075 .mismatch = DATA_TO_ANY_EXIT, 1076 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 1077}, 1078/* Do not reference init code/data from meminit code/data */ 1079{ 1080 .fromsec = { ALL_XXXINIT_SECTIONS, NULL }, 1081 .bad_tosec = { INIT_SECTIONS, NULL }, 1082 .mismatch = XXXINIT_TO_SOME_INIT, 1083 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 1084}, 1085/* Do not reference exit code/data from memexit code/data */ 1086{ 1087 .fromsec = { ALL_XXXEXIT_SECTIONS, NULL }, 1088 .bad_tosec = { EXIT_SECTIONS, NULL }, 1089 .mismatch = XXXEXIT_TO_SOME_EXIT, 1090 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 1091}, 1092/* Do not use exit code/data from init code */ 1093{ 1094 .fromsec = { ALL_INIT_SECTIONS, NULL }, 1095 .bad_tosec = { ALL_EXIT_SECTIONS, NULL }, 1096 .mismatch = ANY_INIT_TO_ANY_EXIT, 1097 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 1098}, 1099/* Do not use init code/data from exit code */ 1100{ 1101 .fromsec = { ALL_EXIT_SECTIONS, NULL }, 1102 .bad_tosec = { ALL_INIT_SECTIONS, NULL }, 1103 .mismatch = ANY_EXIT_TO_ANY_INIT, 1104 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 1105}, 1106{ 1107 .fromsec = { ALL_PCI_INIT_SECTIONS, NULL }, 1108 .bad_tosec = { INIT_SECTIONS, NULL }, 1109 .mismatch = ANY_INIT_TO_ANY_EXIT, 1110 .symbol_white_list = { NULL }, 1111}, 1112/* Do not export init/exit functions or data */ 1113{ 1114 .fromsec = { "___ksymtab*", NULL }, 1115 .bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL }, 1116 .mismatch = EXPORT_TO_INIT_EXIT, 1117 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 1118}, 1119{ 1120 .fromsec = { "__ex_table", NULL }, 1121 /* If you're adding any new black-listed sections in here, consider 1122 * adding a special 'printer' for them in scripts/check_extable. 1123 */ 1124 .bad_tosec = { ".altinstr_replacement", NULL }, 1125 .good_tosec = {ALL_TEXT_SECTIONS , NULL}, 1126 .mismatch = EXTABLE_TO_NON_TEXT, 1127 .handler = extable_mismatch_handler, 1128} 1129}; 1130 1131static const struct sectioncheck *section_mismatch( 1132 const char *fromsec, const char *tosec) 1133{ 1134 int i; 1135 int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck); 1136 const struct sectioncheck *check = §ioncheck[0]; 1137 1138 /* 1139 * The target section could be the SHT_NUL section when we're 1140 * handling relocations to un-resolved symbols, trying to match it 1141 * doesn't make much sense and causes build failures on parisc 1142 * architectures. 1143 */ 1144 if (*tosec == '\0') 1145 return NULL; 1146 1147 for (i = 0; i < elems; i++) { 1148 if (match(fromsec, check->fromsec)) { 1149 if (check->bad_tosec[0] && match(tosec, check->bad_tosec)) 1150 return check; 1151 if (check->good_tosec[0] && !match(tosec, check->good_tosec)) 1152 return check; 1153 } 1154 check++; 1155 } 1156 return NULL; 1157} 1158 1159/** 1160 * Whitelist to allow certain references to pass with no warning. 1161 * 1162 * Pattern 1: 1163 * If a module parameter is declared __initdata and permissions=0 1164 * then this is legal despite the warning generated. 1165 * We cannot see value of permissions here, so just ignore 1166 * this pattern. 1167 * The pattern is identified by: 1168 * tosec = .init.data 1169 * fromsec = .data* 1170 * atsym =__param* 1171 * 1172 * Pattern 1a: 1173 * module_param_call() ops can refer to __init set function if permissions=0 1174 * The pattern is identified by: 1175 * tosec = .init.text 1176 * fromsec = .data* 1177 * atsym = __param_ops_* 1178 * 1179 * Pattern 2: 1180 * Many drivers utilise a *driver container with references to 1181 * add, remove, probe functions etc. 1182 * the pattern is identified by: 1183 * tosec = init or exit section 1184 * fromsec = data section 1185 * atsym = *driver, *_template, *_sht, *_ops, *_probe, 1186 * *probe_one, *_console, *_timer 1187 * 1188 * Pattern 3: 1189 * Whitelist all references from .head.text to any init section 1190 * 1191 * Pattern 4: 1192 * Some symbols belong to init section but still it is ok to reference 1193 * these from non-init sections as these symbols don't have any memory 1194 * allocated for them and symbol address and value are same. So even 1195 * if init section is freed, its ok to reference those symbols. 1196 * For ex. symbols marking the init section boundaries. 1197 * This pattern is identified by 1198 * refsymname = __init_begin, _sinittext, _einittext 1199 * 1200 * Pattern 5: 1201 * GCC may optimize static inlines when fed constant arg(s) resulting 1202 * in functions like cpumask_empty() -- generating an associated symbol 1203 * cpumask_empty.constprop.3 that appears in the audit. If the const that 1204 * is passed in comes from __init, like say nmi_ipi_mask, we get a 1205 * meaningless section warning. May need to add isra symbols too... 1206 * This pattern is identified by 1207 * tosec = init section 1208 * fromsec = text section 1209 * refsymname = *.constprop.* 1210 * 1211 * Pattern 6: 1212 * Hide section mismatch warnings for ELF local symbols. The goal 1213 * is to eliminate false positive modpost warnings caused by 1214 * compiler-generated ELF local symbol names such as ".LANCHOR1". 1215 * Autogenerated symbol names bypass modpost's "Pattern 2" 1216 * whitelisting, which relies on pattern-matching against symbol 1217 * names to work. (One situation where gcc can autogenerate ELF 1218 * local symbols is when "-fsection-anchors" is used.) 1219 **/ 1220static int secref_whitelist(const struct sectioncheck *mismatch, 1221 const char *fromsec, const char *fromsym, 1222 const char *tosec, const char *tosym) 1223{ 1224 /* Check for pattern 1 */ 1225 if (match(tosec, init_data_sections) && 1226 match(fromsec, data_sections) && 1227 strstarts(fromsym, "__param")) 1228 return 0; 1229 1230 /* Check for pattern 1a */ 1231 if (strcmp(tosec, ".init.text") == 0 && 1232 match(fromsec, data_sections) && 1233 strstarts(fromsym, "__param_ops_")) 1234 return 0; 1235 1236 /* Check for pattern 2 */ 1237 if (match(tosec, init_exit_sections) && 1238 match(fromsec, data_sections) && 1239 match(fromsym, mismatch->symbol_white_list)) 1240 return 0; 1241 1242 /* Check for pattern 3 */ 1243 if (match(fromsec, head_sections) && 1244 match(tosec, init_sections)) 1245 return 0; 1246 1247 /* Check for pattern 4 */ 1248 if (match(tosym, linker_symbols)) 1249 return 0; 1250 1251 /* Check for pattern 5 */ 1252 if (match(fromsec, text_sections) && 1253 match(tosec, init_sections) && 1254 match(fromsym, optim_symbols)) 1255 return 0; 1256 1257 /* Check for pattern 6 */ 1258 if (strstarts(fromsym, ".L")) 1259 return 0; 1260 1261 return 1; 1262} 1263 1264static inline int is_arm_mapping_symbol(const char *str) 1265{ 1266 return str[0] == '$' && 1267 (str[1] == 'a' || str[1] == 'd' || str[1] == 't' || str[1] == 'x') 1268 && (str[2] == '\0' || str[2] == '.'); 1269} 1270 1271/* 1272 * If there's no name there, ignore it; likewise, ignore it if it's 1273 * one of the magic symbols emitted used by current ARM tools. 1274 * 1275 * Otherwise if find_symbols_between() returns those symbols, they'll 1276 * fail the whitelist tests and cause lots of false alarms ... fixable 1277 * only by merging __exit and __init sections into __text, bloating 1278 * the kernel (which is especially evil on embedded platforms). 1279 */ 1280static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym) 1281{ 1282 const char *name = elf->strtab + sym->st_name; 1283 1284 if (!name || !strlen(name)) 1285 return 0; 1286 return !is_arm_mapping_symbol(name); 1287} 1288 1289/** 1290 * Find symbol based on relocation record info. 1291 * In some cases the symbol supplied is a valid symbol so 1292 * return refsym. If st_name != 0 we assume this is a valid symbol. 1293 * In other cases the symbol needs to be looked up in the symbol table 1294 * based on section and address. 1295 * **/ 1296static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr, 1297 Elf_Sym *relsym) 1298{ 1299 Elf_Sym *sym; 1300 Elf_Sym *near = NULL; 1301 Elf64_Sword distance = 20; 1302 Elf64_Sword d; 1303 unsigned int relsym_secindex; 1304 1305 if (relsym->st_name != 0) 1306 return relsym; 1307 1308 /* 1309 * Strive to find a better symbol name, but the resulting name may not 1310 * match the symbol referenced in the original code. 1311 */ 1312 relsym_secindex = get_secindex(elf, relsym); 1313 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) { 1314 if (get_secindex(elf, sym) != relsym_secindex) 1315 continue; 1316 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION) 1317 continue; 1318 if (!is_valid_name(elf, sym)) 1319 continue; 1320 if (sym->st_value == addr) 1321 return sym; 1322 /* Find a symbol nearby - addr are maybe negative */ 1323 d = sym->st_value - addr; 1324 if (d < 0) 1325 d = addr - sym->st_value; 1326 if (d < distance) { 1327 distance = d; 1328 near = sym; 1329 } 1330 } 1331 /* We need a close match */ 1332 if (distance < 20) 1333 return near; 1334 else 1335 return NULL; 1336} 1337 1338/* 1339 * Find symbols before or equal addr and after addr - in the section sec. 1340 * If we find two symbols with equal offset prefer one with a valid name. 1341 * The ELF format may have a better way to detect what type of symbol 1342 * it is, but this works for now. 1343 **/ 1344static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr, 1345 const char *sec) 1346{ 1347 Elf_Sym *sym; 1348 Elf_Sym *near = NULL; 1349 Elf_Addr distance = ~0; 1350 1351 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) { 1352 const char *symsec; 1353 1354 if (is_shndx_special(sym->st_shndx)) 1355 continue; 1356 symsec = sec_name(elf, get_secindex(elf, sym)); 1357 if (strcmp(symsec, sec) != 0) 1358 continue; 1359 if (!is_valid_name(elf, sym)) 1360 continue; 1361 if (sym->st_value <= addr) { 1362 if ((addr - sym->st_value) < distance) { 1363 distance = addr - sym->st_value; 1364 near = sym; 1365 } else if ((addr - sym->st_value) == distance) { 1366 near = sym; 1367 } 1368 } 1369 } 1370 return near; 1371} 1372 1373/* 1374 * Convert a section name to the function/data attribute 1375 * .init.text => __init 1376 * .memexitconst => __memconst 1377 * etc. 1378 * 1379 * The memory of returned value has been allocated on a heap. The user of this 1380 * method should free it after usage. 1381*/ 1382static char *sec2annotation(const char *s) 1383{ 1384 if (match(s, init_exit_sections)) { 1385 char *p = NOFAIL(malloc(20)); 1386 char *r = p; 1387 1388 *p++ = '_'; 1389 *p++ = '_'; 1390 if (*s == '.') 1391 s++; 1392 while (*s && *s != '.') 1393 *p++ = *s++; 1394 *p = '\0'; 1395 if (*s == '.') 1396 s++; 1397 if (strstr(s, "rodata") != NULL) 1398 strcat(p, "const "); 1399 else if (strstr(s, "data") != NULL) 1400 strcat(p, "data "); 1401 else 1402 strcat(p, " "); 1403 return r; 1404 } else { 1405 return NOFAIL(strdup("")); 1406 } 1407} 1408 1409static int is_function(Elf_Sym *sym) 1410{ 1411 if (sym) 1412 return ELF_ST_TYPE(sym->st_info) == STT_FUNC; 1413 else 1414 return -1; 1415} 1416 1417static void print_section_list(const char * const list[20]) 1418{ 1419 const char *const *s = list; 1420 1421 while (*s) { 1422 fprintf(stderr, "%s", *s); 1423 s++; 1424 if (*s) 1425 fprintf(stderr, ", "); 1426 } 1427 fprintf(stderr, "\n"); 1428} 1429 1430static inline void get_pretty_name(int is_func, const char** name, const char** name_p) 1431{ 1432 switch (is_func) { 1433 case 0: *name = "variable"; *name_p = ""; break; 1434 case 1: *name = "function"; *name_p = "()"; break; 1435 default: *name = "(unknown reference)"; *name_p = ""; break; 1436 } 1437} 1438 1439/* 1440 * Print a warning about a section mismatch. 1441 * Try to find symbols near it so user can find it. 1442 * Check whitelist before warning - it may be a false positive. 1443 */ 1444static void report_sec_mismatch(const char *modname, 1445 const struct sectioncheck *mismatch, 1446 const char *fromsec, 1447 unsigned long long fromaddr, 1448 const char *fromsym, 1449 int from_is_func, 1450 const char *tosec, const char *tosym, 1451 int to_is_func) 1452{ 1453 const char *from, *from_p; 1454 const char *to, *to_p; 1455 char *prl_from; 1456 char *prl_to; 1457 1458 sec_mismatch_count++; 1459 1460 get_pretty_name(from_is_func, &from, &from_p); 1461 get_pretty_name(to_is_func, &to, &to_p); 1462 1463 warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s " 1464 "to the %s %s:%s%s\n", 1465 modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec, 1466 tosym, to_p); 1467 1468 switch (mismatch->mismatch) { 1469 case TEXT_TO_ANY_INIT: 1470 prl_from = sec2annotation(fromsec); 1471 prl_to = sec2annotation(tosec); 1472 fprintf(stderr, 1473 "The function %s%s() references\n" 1474 "the %s %s%s%s.\n" 1475 "This is often because %s lacks a %s\n" 1476 "annotation or the annotation of %s is wrong.\n", 1477 prl_from, fromsym, 1478 to, prl_to, tosym, to_p, 1479 fromsym, prl_to, tosym); 1480 free(prl_from); 1481 free(prl_to); 1482 break; 1483 case DATA_TO_ANY_INIT: { 1484 prl_to = sec2annotation(tosec); 1485 fprintf(stderr, 1486 "The variable %s references\n" 1487 "the %s %s%s%s\n" 1488 "If the reference is valid then annotate the\n" 1489 "variable with __init* or __refdata (see linux/init.h) " 1490 "or name the variable:\n", 1491 fromsym, to, prl_to, tosym, to_p); 1492 print_section_list(mismatch->symbol_white_list); 1493 free(prl_to); 1494 break; 1495 } 1496 case TEXT_TO_ANY_EXIT: 1497 prl_to = sec2annotation(tosec); 1498 fprintf(stderr, 1499 "The function %s() references a %s in an exit section.\n" 1500 "Often the %s %s%s has valid usage outside the exit section\n" 1501 "and the fix is to remove the %sannotation of %s.\n", 1502 fromsym, to, to, tosym, to_p, prl_to, tosym); 1503 free(prl_to); 1504 break; 1505 case DATA_TO_ANY_EXIT: { 1506 prl_to = sec2annotation(tosec); 1507 fprintf(stderr, 1508 "The variable %s references\n" 1509 "the %s %s%s%s\n" 1510 "If the reference is valid then annotate the\n" 1511 "variable with __exit* (see linux/init.h) or " 1512 "name the variable:\n", 1513 fromsym, to, prl_to, tosym, to_p); 1514 print_section_list(mismatch->symbol_white_list); 1515 free(prl_to); 1516 break; 1517 } 1518 case XXXINIT_TO_SOME_INIT: 1519 case XXXEXIT_TO_SOME_EXIT: 1520 prl_from = sec2annotation(fromsec); 1521 prl_to = sec2annotation(tosec); 1522 fprintf(stderr, 1523 "The %s %s%s%s references\n" 1524 "a %s %s%s%s.\n" 1525 "If %s is only used by %s then\n" 1526 "annotate %s with a matching annotation.\n", 1527 from, prl_from, fromsym, from_p, 1528 to, prl_to, tosym, to_p, 1529 tosym, fromsym, tosym); 1530 free(prl_from); 1531 free(prl_to); 1532 break; 1533 case ANY_INIT_TO_ANY_EXIT: 1534 prl_from = sec2annotation(fromsec); 1535 prl_to = sec2annotation(tosec); 1536 fprintf(stderr, 1537 "The %s %s%s%s references\n" 1538 "a %s %s%s%s.\n" 1539 "This is often seen when error handling " 1540 "in the init function\n" 1541 "uses functionality in the exit path.\n" 1542 "The fix is often to remove the %sannotation of\n" 1543 "%s%s so it may be used outside an exit section.\n", 1544 from, prl_from, fromsym, from_p, 1545 to, prl_to, tosym, to_p, 1546 prl_to, tosym, to_p); 1547 free(prl_from); 1548 free(prl_to); 1549 break; 1550 case ANY_EXIT_TO_ANY_INIT: 1551 prl_from = sec2annotation(fromsec); 1552 prl_to = sec2annotation(tosec); 1553 fprintf(stderr, 1554 "The %s %s%s%s references\n" 1555 "a %s %s%s%s.\n" 1556 "This is often seen when error handling " 1557 "in the exit function\n" 1558 "uses functionality in the init path.\n" 1559 "The fix is often to remove the %sannotation of\n" 1560 "%s%s so it may be used outside an init section.\n", 1561 from, prl_from, fromsym, from_p, 1562 to, prl_to, tosym, to_p, 1563 prl_to, tosym, to_p); 1564 free(prl_from); 1565 free(prl_to); 1566 break; 1567 case EXPORT_TO_INIT_EXIT: 1568 prl_to = sec2annotation(tosec); 1569 fprintf(stderr, 1570 "The symbol %s is exported and annotated %s\n" 1571 "Fix this by removing the %sannotation of %s " 1572 "or drop the export.\n", 1573 tosym, prl_to, prl_to, tosym); 1574 free(prl_to); 1575 break; 1576 case EXTABLE_TO_NON_TEXT: 1577 fatal("There's a special handler for this mismatch type, " 1578 "we should never get here."); 1579 break; 1580 } 1581 fprintf(stderr, "\n"); 1582} 1583 1584static void default_mismatch_handler(const char *modname, struct elf_info *elf, 1585 const struct sectioncheck* const mismatch, 1586 Elf_Rela *r, Elf_Sym *sym, const char *fromsec) 1587{ 1588 const char *tosec; 1589 Elf_Sym *to; 1590 Elf_Sym *from; 1591 const char *tosym; 1592 const char *fromsym; 1593 1594 from = find_elf_symbol2(elf, r->r_offset, fromsec); 1595 fromsym = sym_name(elf, from); 1596 1597 if (strstarts(fromsym, "reference___initcall")) 1598 return; 1599 1600 tosec = sec_name(elf, get_secindex(elf, sym)); 1601 to = find_elf_symbol(elf, r->r_addend, sym); 1602 tosym = sym_name(elf, to); 1603 1604 /* check whitelist - we may ignore it */ 1605 if (secref_whitelist(mismatch, 1606 fromsec, fromsym, tosec, tosym)) { 1607 report_sec_mismatch(modname, mismatch, 1608 fromsec, r->r_offset, fromsym, 1609 is_function(from), tosec, tosym, 1610 is_function(to)); 1611 } 1612} 1613 1614static int is_executable_section(struct elf_info* elf, unsigned int section_index) 1615{ 1616 if (section_index >= elf->num_sections) 1617 fatal("section_index is outside elf->num_sections!\n"); 1618 1619 return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR); 1620} 1621 1622/* 1623 * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size() 1624 * to know the sizeof(struct exception_table_entry) for the target architecture. 1625 */ 1626static unsigned int extable_entry_size = 0; 1627static void find_extable_entry_size(const char* const sec, const Elf_Rela* r) 1628{ 1629 /* 1630 * If we're currently checking the second relocation within __ex_table, 1631 * that relocation offset tells us the offsetof(struct 1632 * exception_table_entry, fixup) which is equal to sizeof(struct 1633 * exception_table_entry) divided by two. We use that to our advantage 1634 * since there's no portable way to get that size as every architecture 1635 * seems to go with different sized types. Not pretty but better than 1636 * hard-coding the size for every architecture.. 1637 */ 1638 if (!extable_entry_size) 1639 extable_entry_size = r->r_offset * 2; 1640} 1641 1642static inline bool is_extable_fault_address(Elf_Rela *r) 1643{ 1644 /* 1645 * extable_entry_size is only discovered after we've handled the 1646 * _second_ relocation in __ex_table, so only abort when we're not 1647 * handling the first reloc and extable_entry_size is zero. 1648 */ 1649 if (r->r_offset && extable_entry_size == 0) 1650 fatal("extable_entry size hasn't been discovered!\n"); 1651 1652 return ((r->r_offset == 0) || 1653 (r->r_offset % extable_entry_size == 0)); 1654} 1655 1656#define is_second_extable_reloc(Start, Cur, Sec) \ 1657 (((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0)) 1658 1659static void report_extable_warnings(const char* modname, struct elf_info* elf, 1660 const struct sectioncheck* const mismatch, 1661 Elf_Rela* r, Elf_Sym* sym, 1662 const char* fromsec, const char* tosec) 1663{ 1664 Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec); 1665 const char* fromsym_name = sym_name(elf, fromsym); 1666 Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym); 1667 const char* tosym_name = sym_name(elf, tosym); 1668 const char* from_pretty_name; 1669 const char* from_pretty_name_p; 1670 const char* to_pretty_name; 1671 const char* to_pretty_name_p; 1672 1673 get_pretty_name(is_function(fromsym), 1674 &from_pretty_name, &from_pretty_name_p); 1675 get_pretty_name(is_function(tosym), 1676 &to_pretty_name, &to_pretty_name_p); 1677 1678 warn("%s(%s+0x%lx): Section mismatch in reference" 1679 " from the %s %s%s to the %s %s:%s%s\n", 1680 modname, fromsec, (long)r->r_offset, from_pretty_name, 1681 fromsym_name, from_pretty_name_p, 1682 to_pretty_name, tosec, tosym_name, to_pretty_name_p); 1683 1684 if (!match(tosec, mismatch->bad_tosec) && 1685 is_executable_section(elf, get_secindex(elf, sym))) 1686 fprintf(stderr, 1687 "The relocation at %s+0x%lx references\n" 1688 "section \"%s\" which is not in the list of\n" 1689 "authorized sections. If you're adding a new section\n" 1690 "and/or if this reference is valid, add \"%s\" to the\n" 1691 "list of authorized sections to jump to on fault.\n" 1692 "This can be achieved by adding \"%s\" to \n" 1693 "OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n", 1694 fromsec, (long)r->r_offset, tosec, tosec, tosec); 1695} 1696 1697static void extable_mismatch_handler(const char* modname, struct elf_info *elf, 1698 const struct sectioncheck* const mismatch, 1699 Elf_Rela* r, Elf_Sym* sym, 1700 const char *fromsec) 1701{ 1702 const char* tosec = sec_name(elf, get_secindex(elf, sym)); 1703 1704 sec_mismatch_count++; 1705 1706 report_extable_warnings(modname, elf, mismatch, r, sym, fromsec, tosec); 1707 1708 if (match(tosec, mismatch->bad_tosec)) 1709 fatal("The relocation at %s+0x%lx references\n" 1710 "section \"%s\" which is black-listed.\n" 1711 "Something is seriously wrong and should be fixed.\n" 1712 "You might get more information about where this is\n" 1713 "coming from by using scripts/check_extable.sh %s\n", 1714 fromsec, (long)r->r_offset, tosec, modname); 1715 else if (!is_executable_section(elf, get_secindex(elf, sym))) { 1716 if (is_extable_fault_address(r)) 1717 fatal("The relocation at %s+0x%lx references\n" 1718 "section \"%s\" which is not executable, IOW\n" 1719 "it is not possible for the kernel to fault\n" 1720 "at that address. Something is seriously wrong\n" 1721 "and should be fixed.\n", 1722 fromsec, (long)r->r_offset, tosec); 1723 else 1724 fatal("The relocation at %s+0x%lx references\n" 1725 "section \"%s\" which is not executable, IOW\n" 1726 "the kernel will fault if it ever tries to\n" 1727 "jump to it. Something is seriously wrong\n" 1728 "and should be fixed.\n", 1729 fromsec, (long)r->r_offset, tosec); 1730 } 1731} 1732 1733static void check_section_mismatch(const char *modname, struct elf_info *elf, 1734 Elf_Rela *r, Elf_Sym *sym, const char *fromsec) 1735{ 1736 const char *tosec = sec_name(elf, get_secindex(elf, sym)); 1737 const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec); 1738 1739 if (mismatch) { 1740 if (mismatch->handler) 1741 mismatch->handler(modname, elf, mismatch, 1742 r, sym, fromsec); 1743 else 1744 default_mismatch_handler(modname, elf, mismatch, 1745 r, sym, fromsec); 1746 } 1747} 1748 1749static unsigned int *reloc_location(struct elf_info *elf, 1750 Elf_Shdr *sechdr, Elf_Rela *r) 1751{ 1752 return sym_get_data_by_offset(elf, sechdr->sh_info, r->r_offset); 1753} 1754 1755static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r) 1756{ 1757 unsigned int r_typ = ELF_R_TYPE(r->r_info); 1758 unsigned int *location = reloc_location(elf, sechdr, r); 1759 1760 switch (r_typ) { 1761 case R_386_32: 1762 r->r_addend = TO_NATIVE(*location); 1763 break; 1764 case R_386_PC32: 1765 r->r_addend = TO_NATIVE(*location) + 4; 1766 /* For CONFIG_RELOCATABLE=y */ 1767 if (elf->hdr->e_type == ET_EXEC) 1768 r->r_addend += r->r_offset; 1769 break; 1770 } 1771 return 0; 1772} 1773 1774#ifndef R_ARM_CALL 1775#define R_ARM_CALL 28 1776#endif 1777#ifndef R_ARM_JUMP24 1778#define R_ARM_JUMP24 29 1779#endif 1780 1781#ifndef R_ARM_THM_CALL 1782#define R_ARM_THM_CALL 10 1783#endif 1784#ifndef R_ARM_THM_JUMP24 1785#define R_ARM_THM_JUMP24 30 1786#endif 1787#ifndef R_ARM_THM_JUMP19 1788#define R_ARM_THM_JUMP19 51 1789#endif 1790 1791static int32_t sign_extend32(int32_t value, int index) 1792{ 1793 uint8_t shift = 31 - index; 1794 1795 return (int32_t)(value << shift) >> shift; 1796} 1797 1798static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r) 1799{ 1800 unsigned int r_typ = ELF_R_TYPE(r->r_info); 1801 Elf_Sym *sym = elf->symtab_start + ELF_R_SYM(r->r_info); 1802 void *loc = reloc_location(elf, sechdr, r); 1803 uint32_t inst; 1804 int32_t offset; 1805 1806 switch (r_typ) { 1807 case R_ARM_ABS32: 1808 inst = TO_NATIVE(*(uint32_t *)loc); 1809 r->r_addend = inst + sym->st_value; 1810 break; 1811 case R_ARM_PC24: 1812 case R_ARM_CALL: 1813 case R_ARM_JUMP24: 1814 inst = TO_NATIVE(*(uint32_t *)loc); 1815 offset = sign_extend32((inst & 0x00ffffff) << 2, 25); 1816 r->r_addend = offset + sym->st_value + 8; 1817 break; 1818 case R_ARM_THM_CALL: 1819 case R_ARM_THM_JUMP24: 1820 case R_ARM_THM_JUMP19: 1821 /* From ARM ABI: ((S + A) | T) - P */ 1822 r->r_addend = (int)(long)(elf->hdr + 1823 sechdr->sh_offset + 1824 (r->r_offset - sechdr->sh_addr)); 1825 break; 1826 default: 1827 return 1; 1828 } 1829 return 0; 1830} 1831 1832static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r) 1833{ 1834 unsigned int r_typ = ELF_R_TYPE(r->r_info); 1835 unsigned int *location = reloc_location(elf, sechdr, r); 1836 unsigned int inst; 1837 1838 if (r_typ == R_MIPS_HI16) 1839 return 1; /* skip this */ 1840 inst = TO_NATIVE(*location); 1841 switch (r_typ) { 1842 case R_MIPS_LO16: 1843 r->r_addend = inst & 0xffff; 1844 break; 1845 case R_MIPS_26: 1846 r->r_addend = (inst & 0x03ffffff) << 2; 1847 break; 1848 case R_MIPS_32: 1849 r->r_addend = inst; 1850 break; 1851 } 1852 return 0; 1853} 1854 1855#ifndef EM_LOONGARCH 1856#define EM_LOONGARCH 258 1857#endif 1858 1859#ifndef R_LARCH_SUB32 1860#define R_LARCH_SUB32 55 1861#endif 1862 1863static void section_rela(const char *modname, struct elf_info *elf, 1864 Elf_Shdr *sechdr) 1865{ 1866 Elf_Sym *sym; 1867 Elf_Rela *rela; 1868 Elf_Rela r; 1869 unsigned int r_sym; 1870 const char *fromsec; 1871 1872 Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset; 1873 Elf_Rela *stop = (void *)start + sechdr->sh_size; 1874 1875 fromsec = sech_name(elf, sechdr); 1876 fromsec += strlen(".rela"); 1877 /* if from section (name) is know good then skip it */ 1878 if (match(fromsec, section_white_list)) 1879 return; 1880 1881 for (rela = start; rela < stop; rela++) { 1882 r.r_offset = TO_NATIVE(rela->r_offset); 1883#if KERNEL_ELFCLASS == ELFCLASS64 1884 if (elf->hdr->e_machine == EM_MIPS) { 1885 unsigned int r_typ; 1886 r_sym = ELF64_MIPS_R_SYM(rela->r_info); 1887 r_sym = TO_NATIVE(r_sym); 1888 r_typ = ELF64_MIPS_R_TYPE(rela->r_info); 1889 r.r_info = ELF64_R_INFO(r_sym, r_typ); 1890 } else { 1891 r.r_info = TO_NATIVE(rela->r_info); 1892 r_sym = ELF_R_SYM(r.r_info); 1893 } 1894#else 1895 r.r_info = TO_NATIVE(rela->r_info); 1896 r_sym = ELF_R_SYM(r.r_info); 1897#endif 1898 r.r_addend = TO_NATIVE(rela->r_addend); 1899 switch (elf->hdr->e_machine) { 1900 case EM_LOONGARCH: 1901 if (!strcmp("__ex_table", fromsec) && 1902 ELF_R_TYPE(r.r_info) == R_LARCH_SUB32) 1903 continue; 1904 break; 1905 } 1906 sym = elf->symtab_start + r_sym; 1907 /* Skip special sections */ 1908 if (is_shndx_special(sym->st_shndx)) 1909 continue; 1910 if (is_second_extable_reloc(start, rela, fromsec)) 1911 find_extable_entry_size(fromsec, &r); 1912 check_section_mismatch(modname, elf, &r, sym, fromsec); 1913 } 1914} 1915 1916static void section_rel(const char *modname, struct elf_info *elf, 1917 Elf_Shdr *sechdr) 1918{ 1919 Elf_Sym *sym; 1920 Elf_Rel *rel; 1921 Elf_Rela r; 1922 unsigned int r_sym; 1923 const char *fromsec; 1924 1925 Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset; 1926 Elf_Rel *stop = (void *)start + sechdr->sh_size; 1927 1928 fromsec = sech_name(elf, sechdr); 1929 fromsec += strlen(".rel"); 1930 /* if from section (name) is know good then skip it */ 1931 if (match(fromsec, section_white_list)) 1932 return; 1933 1934 for (rel = start; rel < stop; rel++) { 1935 r.r_offset = TO_NATIVE(rel->r_offset); 1936#if KERNEL_ELFCLASS == ELFCLASS64 1937 if (elf->hdr->e_machine == EM_MIPS) { 1938 unsigned int r_typ; 1939 r_sym = ELF64_MIPS_R_SYM(rel->r_info); 1940 r_sym = TO_NATIVE(r_sym); 1941 r_typ = ELF64_MIPS_R_TYPE(rel->r_info); 1942 r.r_info = ELF64_R_INFO(r_sym, r_typ); 1943 } else { 1944 r.r_info = TO_NATIVE(rel->r_info); 1945 r_sym = ELF_R_SYM(r.r_info); 1946 } 1947#else 1948 r.r_info = TO_NATIVE(rel->r_info); 1949 r_sym = ELF_R_SYM(r.r_info); 1950#endif 1951 r.r_addend = 0; 1952 switch (elf->hdr->e_machine) { 1953 case EM_386: 1954 if (addend_386_rel(elf, sechdr, &r)) 1955 continue; 1956 break; 1957 case EM_ARM: 1958 if (addend_arm_rel(elf, sechdr, &r)) 1959 continue; 1960 break; 1961 case EM_MIPS: 1962 if (addend_mips_rel(elf, sechdr, &r)) 1963 continue; 1964 break; 1965 } 1966 sym = elf->symtab_start + r_sym; 1967 /* Skip special sections */ 1968 if (is_shndx_special(sym->st_shndx)) 1969 continue; 1970 if (is_second_extable_reloc(start, rel, fromsec)) 1971 find_extable_entry_size(fromsec, &r); 1972 check_section_mismatch(modname, elf, &r, sym, fromsec); 1973 } 1974} 1975 1976/** 1977 * A module includes a number of sections that are discarded 1978 * either when loaded or when used as built-in. 1979 * For loaded modules all functions marked __init and all data 1980 * marked __initdata will be discarded when the module has been initialized. 1981 * Likewise for modules used built-in the sections marked __exit 1982 * are discarded because __exit marked function are supposed to be called 1983 * only when a module is unloaded which never happens for built-in modules. 1984 * The check_sec_ref() function traverses all relocation records 1985 * to find all references to a section that reference a section that will 1986 * be discarded and warns about it. 1987 **/ 1988static void check_sec_ref(struct module *mod, const char *modname, 1989 struct elf_info *elf) 1990{ 1991 int i; 1992 Elf_Shdr *sechdrs = elf->sechdrs; 1993 1994 /* Walk through all sections */ 1995 for (i = 0; i < elf->num_sections; i++) { 1996 check_section(modname, elf, &elf->sechdrs[i]); 1997 /* We want to process only relocation sections and not .init */ 1998 if (sechdrs[i].sh_type == SHT_RELA) 1999 section_rela(modname, elf, &elf->sechdrs[i]); 2000 else if (sechdrs[i].sh_type == SHT_REL) 2001 section_rel(modname, elf, &elf->sechdrs[i]); 2002 } 2003} 2004 2005static char *remove_dot(char *s) 2006{ 2007 size_t n = strcspn(s, "."); 2008 2009 if (n && s[n]) { 2010 size_t m = strspn(s + n + 1, "0123456789"); 2011 if (m && (s[n + m + 1] == '.' || s[n + m + 1] == 0)) 2012 s[n] = 0; 2013 2014 /* strip trailing .lto */ 2015 if (strends(s, ".lto")) 2016 s[strlen(s) - 4] = '\0'; 2017 } 2018 return s; 2019} 2020 2021static void read_symbols(const char *modname) 2022{ 2023 const char *symname; 2024 char *version; 2025 char *license; 2026 char *namespace; 2027 struct module *mod; 2028 struct elf_info info = { }; 2029 Elf_Sym *sym; 2030 2031 if (!parse_elf(&info, modname)) 2032 return; 2033 2034 { 2035 char *tmp; 2036 2037 /* strip trailing .o */ 2038 tmp = NOFAIL(strdup(modname)); 2039 tmp[strlen(tmp) - 2] = '\0'; 2040 /* strip trailing .lto */ 2041 if (strends(tmp, ".lto")) 2042 tmp[strlen(tmp) - 4] = '\0'; 2043 mod = new_module(tmp); 2044 free(tmp); 2045 } 2046 2047 if (!mod->is_vmlinux) { 2048 license = get_modinfo(&info, "license"); 2049 if (!license) 2050 warn("missing MODULE_LICENSE() in %s\n", modname); 2051 while (license) { 2052 if (license_is_gpl_compatible(license)) 2053 mod->gpl_compatible = 1; 2054 else { 2055 mod->gpl_compatible = 0; 2056 break; 2057 } 2058 license = get_next_modinfo(&info, "license", license); 2059 } 2060 2061 namespace = get_modinfo(&info, "import_ns"); 2062 while (namespace) { 2063 add_namespace(&mod->imported_namespaces, namespace); 2064 namespace = get_next_modinfo(&info, "import_ns", 2065 namespace); 2066 } 2067 } 2068 2069 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) { 2070 symname = remove_dot(info.strtab + sym->st_name); 2071 2072 handle_symbol(mod, &info, sym, symname); 2073 handle_moddevtable(mod, &info, sym, symname); 2074 } 2075 2076 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) { 2077 symname = remove_dot(info.strtab + sym->st_name); 2078 2079 /* Apply symbol namespaces from __kstrtabns_<symbol> entries. */ 2080 if (strstarts(symname, "__kstrtabns_")) 2081 sym_update_namespace(symname + strlen("__kstrtabns_"), 2082 namespace_from_kstrtabns(&info, 2083 sym)); 2084 2085 if (strstarts(symname, "__crc_")) 2086 handle_modversion(mod, &info, sym, 2087 symname + strlen("__crc_")); 2088 } 2089 2090 // check for static EXPORT_SYMBOL_* functions && global vars 2091 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) { 2092 unsigned char bind = ELF_ST_BIND(sym->st_info); 2093 2094 if (bind == STB_GLOBAL || bind == STB_WEAK) { 2095 struct symbol *s = 2096 find_symbol(remove_dot(info.strtab + 2097 sym->st_name)); 2098 2099 if (s) 2100 s->is_static = 0; 2101 } 2102 } 2103 2104 check_sec_ref(mod, modname, &info); 2105 2106 if (!mod->is_vmlinux) { 2107 version = get_modinfo(&info, "version"); 2108 if (version || all_versions) 2109 get_src_version(modname, mod->srcversion, 2110 sizeof(mod->srcversion) - 1); 2111 } 2112 2113 parse_elf_finish(&info); 2114 2115 /* Our trick to get versioning for module struct etc. - it's 2116 * never passed as an argument to an exported function, so 2117 * the automatic versioning doesn't pick it up, but it's really 2118 * important anyhow */ 2119 if (modversions) 2120 mod->unres = alloc_symbol("module_layout", 0, mod->unres); 2121} 2122 2123static void read_symbols_from_files(const char *filename) 2124{ 2125 FILE *in = stdin; 2126 char fname[PATH_MAX]; 2127 2128 if (strcmp(filename, "-") != 0) { 2129 in = fopen(filename, "r"); 2130 if (!in) 2131 fatal("Can't open filenames file %s: %m", filename); 2132 } 2133 2134 while (fgets(fname, PATH_MAX, in) != NULL) { 2135 if (strends(fname, "\n")) 2136 fname[strlen(fname)-1] = '\0'; 2137 read_symbols(fname); 2138 } 2139 2140 if (in != stdin) 2141 fclose(in); 2142} 2143 2144#define SZ 500 2145 2146/* We first write the generated file into memory using the 2147 * following helper, then compare to the file on disk and 2148 * only update the later if anything changed */ 2149 2150void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf, 2151 const char *fmt, ...) 2152{ 2153 char tmp[SZ]; 2154 int len; 2155 va_list ap; 2156 2157 va_start(ap, fmt); 2158 len = vsnprintf(tmp, SZ, fmt, ap); 2159 buf_write(buf, tmp, len); 2160 va_end(ap); 2161} 2162 2163void buf_write(struct buffer *buf, const char *s, int len) 2164{ 2165 if (buf->size - buf->pos < len) { 2166 buf->size += len + SZ; 2167 buf->p = NOFAIL(realloc(buf->p, buf->size)); 2168 } 2169 strncpy(buf->p + buf->pos, s, len); 2170 buf->pos += len; 2171} 2172 2173static void check_for_gpl_usage(enum export exp, const char *m, const char *s) 2174{ 2175 switch (exp) { 2176 case export_gpl: 2177 fatal("GPL-incompatible module %s.ko uses GPL-only symbol '%s'\n", 2178 m, s); 2179 break; 2180 case export_unused_gpl: 2181 fatal("GPL-incompatible module %s.ko uses GPL-only symbol marked UNUSED '%s'\n", 2182 m, s); 2183 break; 2184 case export_gpl_future: 2185 warn("GPL-incompatible module %s.ko uses future GPL-only symbol '%s'\n", 2186 m, s); 2187 break; 2188 case export_plain: 2189 case export_unused: 2190 case export_unknown: 2191 /* ignore */ 2192 break; 2193 } 2194} 2195 2196static void check_for_unused(enum export exp, const char *m, const char *s) 2197{ 2198 switch (exp) { 2199 case export_unused: 2200 case export_unused_gpl: 2201 warn("module %s.ko uses symbol '%s' marked UNUSED\n", 2202 m, s); 2203 break; 2204 default: 2205 /* ignore */ 2206 break; 2207 } 2208} 2209 2210static int check_exports(struct module *mod) 2211{ 2212 struct symbol *s, *exp; 2213 int err = 0; 2214 2215 for (s = mod->unres; s; s = s->next) { 2216 const char *basename; 2217 exp = find_symbol(s->name); 2218 if (!exp || exp->module == mod) { 2219 if (have_vmlinux && !s->weak) { 2220 modpost_log(warn_unresolved ? LOG_WARN : LOG_ERROR, 2221 "\"%s\" [%s.ko] undefined!\n", 2222 s->name, mod->name); 2223 if (!warn_unresolved) 2224 err = 1; 2225 } 2226 continue; 2227 } 2228 basename = strrchr(mod->name, '/'); 2229 if (basename) 2230 basename++; 2231 else 2232 basename = mod->name; 2233 2234 if (exp->namespace && 2235 !module_imports_namespace(mod, exp->namespace)) { 2236 modpost_log(allow_missing_ns_imports ? LOG_WARN : LOG_ERROR, 2237 "module %s uses symbol %s from namespace %s, but does not import it.\n", 2238 basename, exp->name, exp->namespace); 2239 if (!allow_missing_ns_imports) 2240 err = 1; 2241 add_namespace(&mod->missing_namespaces, exp->namespace); 2242 } 2243 2244 if (!mod->gpl_compatible) 2245 check_for_gpl_usage(exp->export, basename, exp->name); 2246 check_for_unused(exp->export, basename, exp->name); 2247 } 2248 2249 return err; 2250} 2251 2252static int check_modname_len(struct module *mod) 2253{ 2254 const char *mod_name; 2255 2256 mod_name = strrchr(mod->name, '/'); 2257 if (mod_name == NULL) 2258 mod_name = mod->name; 2259 else 2260 mod_name++; 2261 if (strlen(mod_name) >= MODULE_NAME_LEN) { 2262 merror("module name is too long [%s.ko]\n", mod->name); 2263 return 1; 2264 } 2265 2266 return 0; 2267} 2268 2269/** 2270 * Header for the generated file 2271 **/ 2272static void add_header(struct buffer *b, struct module *mod) 2273{ 2274 buf_printf(b, "#include <linux/module.h>\n"); 2275 /* 2276 * Include build-salt.h after module.h in order to 2277 * inherit the definitions. 2278 */ 2279 buf_printf(b, "#define INCLUDE_VERMAGIC\n"); 2280 buf_printf(b, "#include <linux/build-salt.h>\n"); 2281 buf_printf(b, "#include <linux/vermagic.h>\n"); 2282 buf_printf(b, "#include <linux/compiler.h>\n"); 2283 buf_printf(b, "\n"); 2284 buf_printf(b, "BUILD_SALT;\n"); 2285 buf_printf(b, "\n"); 2286 buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n"); 2287 buf_printf(b, "MODULE_INFO(name, KBUILD_MODNAME);\n"); 2288 buf_printf(b, "\n"); 2289 buf_printf(b, "__visible struct module __this_module\n"); 2290 buf_printf(b, "__section(\".gnu.linkonce.this_module\") = {\n"); 2291 buf_printf(b, "\t.name = KBUILD_MODNAME,\n"); 2292 if (mod->has_init) 2293 buf_printf(b, "\t.init = init_module,\n"); 2294 if (mod->has_cleanup) 2295 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n" 2296 "\t.exit = cleanup_module,\n" 2297 "#endif\n"); 2298 buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n"); 2299 buf_printf(b, "};\n"); 2300} 2301 2302static void add_intree_flag(struct buffer *b, int is_intree) 2303{ 2304 if (is_intree) 2305 buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n"); 2306} 2307 2308/* Cannot check for assembler */ 2309static void add_retpoline(struct buffer *b) 2310{ 2311 buf_printf(b, "\n#ifdef CONFIG_RETPOLINE\n"); 2312 buf_printf(b, "MODULE_INFO(retpoline, \"Y\");\n"); 2313 buf_printf(b, "#endif\n"); 2314} 2315 2316static void add_staging_flag(struct buffer *b, const char *name) 2317{ 2318 if (strstarts(name, "drivers/staging")) 2319 buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n"); 2320} 2321 2322/** 2323 * Record CRCs for unresolved symbols 2324 **/ 2325static int add_versions(struct buffer *b, struct module *mod) 2326{ 2327 struct symbol *s, *exp; 2328 int err = 0; 2329 2330 for (s = mod->unres; s; s = s->next) { 2331 exp = find_symbol(s->name); 2332 if (!exp || exp->module == mod) 2333 continue; 2334 s->module = exp->module; 2335 s->crc_valid = exp->crc_valid; 2336 s->crc = exp->crc; 2337 } 2338 2339 if (!modversions) 2340 return err; 2341 2342 buf_printf(b, "\n"); 2343 buf_printf(b, "static const struct modversion_info ____versions[]\n"); 2344 buf_printf(b, "__used __section(\"__versions\") = {\n"); 2345 2346 for (s = mod->unres; s; s = s->next) { 2347 if (!s->module) 2348 continue; 2349 if (!s->crc_valid) { 2350 warn("\"%s\" [%s.ko] has no CRC!\n", 2351 s->name, mod->name); 2352 continue; 2353 } 2354 if (strlen(s->name) >= MODULE_NAME_LEN) { 2355 merror("too long symbol \"%s\" [%s.ko]\n", 2356 s->name, mod->name); 2357 err = 1; 2358 break; 2359 } 2360 buf_printf(b, "\t{ %#8x, \"%s\" },\n", 2361 s->crc, s->name); 2362 } 2363 2364 buf_printf(b, "};\n"); 2365 2366 return err; 2367} 2368 2369static void add_depends(struct buffer *b, struct module *mod) 2370{ 2371 struct symbol *s; 2372 int first = 1; 2373 2374 /* Clear ->seen flag of modules that own symbols needed by this. */ 2375 for (s = mod->unres; s; s = s->next) 2376 if (s->module) 2377 s->module->seen = s->module->is_vmlinux; 2378 2379 buf_printf(b, "\n"); 2380 buf_printf(b, "MODULE_INFO(depends, \""); 2381 for (s = mod->unres; s; s = s->next) { 2382 const char *p; 2383 if (!s->module) 2384 continue; 2385 2386 if (s->module->seen) 2387 continue; 2388 2389 s->module->seen = 1; 2390 p = strrchr(s->module->name, '/'); 2391 if (p) 2392 p++; 2393 else 2394 p = s->module->name; 2395 buf_printf(b, "%s%s", first ? "" : ",", p); 2396 first = 0; 2397 } 2398 buf_printf(b, "\");\n"); 2399} 2400 2401static void add_srcversion(struct buffer *b, struct module *mod) 2402{ 2403 if (mod->srcversion[0]) { 2404 buf_printf(b, "\n"); 2405 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n", 2406 mod->srcversion); 2407 } 2408} 2409 2410static void write_buf(struct buffer *b, const char *fname) 2411{ 2412 FILE *file; 2413 2414 file = fopen(fname, "w"); 2415 if (!file) { 2416 perror(fname); 2417 exit(1); 2418 } 2419 if (fwrite(b->p, 1, b->pos, file) != b->pos) { 2420 perror(fname); 2421 exit(1); 2422 } 2423 if (fclose(file) != 0) { 2424 perror(fname); 2425 exit(1); 2426 } 2427} 2428 2429static void write_if_changed(struct buffer *b, const char *fname) 2430{ 2431 char *tmp; 2432 FILE *file; 2433 struct stat st; 2434 2435 file = fopen(fname, "r"); 2436 if (!file) 2437 goto write; 2438 2439 if (fstat(fileno(file), &st) < 0) 2440 goto close_write; 2441 2442 if (st.st_size != b->pos) 2443 goto close_write; 2444 2445 tmp = NOFAIL(malloc(b->pos)); 2446 if (fread(tmp, 1, b->pos, file) != b->pos) 2447 goto free_write; 2448 2449 if (memcmp(tmp, b->p, b->pos) != 0) 2450 goto free_write; 2451 2452 free(tmp); 2453 fclose(file); 2454 return; 2455 2456 free_write: 2457 free(tmp); 2458 close_write: 2459 fclose(file); 2460 write: 2461 write_buf(b, fname); 2462} 2463 2464/* parse Module.symvers file. line format: 2465 * 0x12345678<tab>symbol<tab>module<tab>export<tab>namespace 2466 **/ 2467static void read_dump(const char *fname) 2468{ 2469 char *buf, *pos, *line; 2470 2471 buf = read_text_file(fname); 2472 if (!buf) 2473 /* No symbol versions, silently ignore */ 2474 return; 2475 2476 pos = buf; 2477 2478 while ((line = get_line(&pos))) { 2479 char *symname, *namespace, *modname, *d, *export; 2480 unsigned int crc; 2481 struct module *mod; 2482 struct symbol *s; 2483 2484 if (!(symname = strchr(line, '\t'))) 2485 goto fail; 2486 *symname++ = '\0'; 2487 if (!(modname = strchr(symname, '\t'))) 2488 goto fail; 2489 *modname++ = '\0'; 2490 if (!(export = strchr(modname, '\t'))) 2491 goto fail; 2492 *export++ = '\0'; 2493 if (!(namespace = strchr(export, '\t'))) 2494 goto fail; 2495 *namespace++ = '\0'; 2496 2497 crc = strtoul(line, &d, 16); 2498 if (*symname == '\0' || *modname == '\0' || *d != '\0') 2499 goto fail; 2500 mod = find_module(modname); 2501 if (!mod) { 2502 mod = new_module(modname); 2503 mod->from_dump = 1; 2504 } 2505 s = sym_add_exported(symname, mod, export_no(export)); 2506 s->is_static = 0; 2507 sym_set_crc(symname, crc); 2508 sym_update_namespace(symname, namespace); 2509 } 2510 free(buf); 2511 return; 2512fail: 2513 free(buf); 2514 fatal("parse error in symbol dump file\n"); 2515} 2516 2517static void write_dump(const char *fname) 2518{ 2519 struct buffer buf = { }; 2520 struct symbol *symbol; 2521 const char *namespace; 2522 int n; 2523 2524 for (n = 0; n < SYMBOL_HASH_SIZE ; n++) { 2525 symbol = symbolhash[n]; 2526 while (symbol) { 2527 if (!symbol->module->from_dump) { 2528 namespace = symbol->namespace; 2529 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\t%s\n", 2530 symbol->crc, symbol->name, 2531 symbol->module->name, 2532 export_str(symbol->export), 2533 namespace ? namespace : ""); 2534 } 2535 symbol = symbol->next; 2536 } 2537 } 2538 write_buf(&buf, fname); 2539 free(buf.p); 2540} 2541 2542static void write_namespace_deps_files(const char *fname) 2543{ 2544 struct module *mod; 2545 struct namespace_list *ns; 2546 struct buffer ns_deps_buf = {}; 2547 2548 for (mod = modules; mod; mod = mod->next) { 2549 2550 if (mod->from_dump || !mod->missing_namespaces) 2551 continue; 2552 2553 buf_printf(&ns_deps_buf, "%s.ko:", mod->name); 2554 2555 for (ns = mod->missing_namespaces; ns; ns = ns->next) 2556 buf_printf(&ns_deps_buf, " %s", ns->namespace); 2557 2558 buf_printf(&ns_deps_buf, "\n"); 2559 } 2560 2561 write_if_changed(&ns_deps_buf, fname); 2562 free(ns_deps_buf.p); 2563} 2564 2565struct dump_list { 2566 struct dump_list *next; 2567 const char *file; 2568}; 2569 2570int main(int argc, char **argv) 2571{ 2572 struct module *mod; 2573 struct buffer buf = { }; 2574 char *missing_namespace_deps = NULL; 2575 char *dump_write = NULL, *files_source = NULL; 2576 int opt; 2577 int err; 2578 int n; 2579 struct dump_list *dump_read_start = NULL; 2580 struct dump_list **dump_read_iter = &dump_read_start; 2581 2582 while ((opt = getopt(argc, argv, "ei:mnT:o:awENd:")) != -1) { 2583 switch (opt) { 2584 case 'e': 2585 external_module = 1; 2586 break; 2587 case 'i': 2588 *dump_read_iter = 2589 NOFAIL(calloc(1, sizeof(**dump_read_iter))); 2590 (*dump_read_iter)->file = optarg; 2591 dump_read_iter = &(*dump_read_iter)->next; 2592 break; 2593 case 'm': 2594 modversions = 1; 2595 break; 2596 case 'n': 2597 ignore_missing_files = 1; 2598 break; 2599 case 'o': 2600 dump_write = optarg; 2601 break; 2602 case 'a': 2603 all_versions = 1; 2604 break; 2605 case 'T': 2606 files_source = optarg; 2607 break; 2608 case 'w': 2609 warn_unresolved = 1; 2610 break; 2611 case 'E': 2612 sec_mismatch_fatal = 1; 2613 break; 2614 case 'N': 2615 allow_missing_ns_imports = 1; 2616 break; 2617 case 'd': 2618 missing_namespace_deps = optarg; 2619 break; 2620 default: 2621 exit(1); 2622 } 2623 } 2624 2625 while (dump_read_start) { 2626 struct dump_list *tmp; 2627 2628 read_dump(dump_read_start->file); 2629 tmp = dump_read_start->next; 2630 free(dump_read_start); 2631 dump_read_start = tmp; 2632 } 2633 2634 while (optind < argc) 2635 read_symbols(argv[optind++]); 2636 2637 if (files_source) 2638 read_symbols_from_files(files_source); 2639 2640 /* 2641 * When there's no vmlinux, don't print warnings about 2642 * unresolved symbols (since there'll be too many ;) 2643 */ 2644 if (!have_vmlinux) 2645 warn("Symbol info of vmlinux is missing. Unresolved symbol check will be entirely skipped.\n"); 2646 2647 err = 0; 2648 2649 for (mod = modules; mod; mod = mod->next) { 2650 char fname[PATH_MAX]; 2651 2652 if (mod->is_vmlinux || mod->from_dump) 2653 continue; 2654 2655 buf.pos = 0; 2656 2657 err |= check_modname_len(mod); 2658 err |= check_exports(mod); 2659 2660 add_header(&buf, mod); 2661 add_intree_flag(&buf, !external_module); 2662 add_retpoline(&buf); 2663 add_staging_flag(&buf, mod->name); 2664 err |= add_versions(&buf, mod); 2665 add_depends(&buf, mod); 2666 add_moddevtable(&buf, mod); 2667 add_srcversion(&buf, mod); 2668 2669 sprintf(fname, "%s.mod.c", mod->name); 2670 write_if_changed(&buf, fname); 2671 } 2672 2673 if (missing_namespace_deps) 2674 write_namespace_deps_files(missing_namespace_deps); 2675 2676 if (dump_write) 2677 write_dump(dump_write); 2678 if (sec_mismatch_count && sec_mismatch_fatal) 2679 fatal("Section mismatches detected.\n" 2680 "Set CONFIG_SECTION_MISMATCH_WARN_ONLY=y to allow them.\n"); 2681 for (n = 0; n < SYMBOL_HASH_SIZE; n++) { 2682 struct symbol *s; 2683 2684 for (s = symbolhash[n]; s; s = s->next) { 2685 if (s->is_static) 2686 warn("\"%s\" [%s] is a static %s\n", 2687 s->name, s->module->name, 2688 export_str(s->export)); 2689 } 2690 } 2691 2692 free(buf.p); 2693 2694 return err; 2695} 2696