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