1/* Modified by Broadcom Corp. Portions Copyright (c) Broadcom Corp, 2012. */ 2/* Postprocess module symbol versions 3 * 4 * Copyright 2003 Kai Germaschewski 5 * Copyright 2002-2004 Rusty Russell, IBM Corporation 6 * Copyright 2006-2008 Sam Ravnborg 7 * Based in part on module-init-tools/depmod.c,file2alias 8 * 9 * This software may be used and distributed according to the terms 10 * of the GNU General Public License, incorporated herein by reference. 11 * 12 * Usage: modpost vmlinux module1.o module2.o ... 13 */ 14 15#define _GNU_SOURCE 16#include <stdio.h> 17#include <ctype.h> 18#include <string.h> 19#include "modpost.h" 20#include "../../include/generated/autoconf.h" 21#include "../../include/linux/license.h" 22 23/* Some toolchains use a `_' prefix for all user symbols. */ 24#ifdef CONFIG_SYMBOL_PREFIX 25#define MODULE_SYMBOL_PREFIX CONFIG_SYMBOL_PREFIX 26#else 27#define MODULE_SYMBOL_PREFIX "" 28#endif 29 30 31/* Are we using CONFIG_MODVERSIONS? */ 32int modversions = 0; 33/* Warn about undefined symbols? (do so if we have vmlinux) */ 34int have_vmlinux = 0; 35/* Is CONFIG_MODULE_SRCVERSION_ALL set? */ 36static int all_versions = 0; 37/* If we are modposting external module set to 1 */ 38static int external_module = 0; 39/* Warn about section mismatch in vmlinux if set to 1 */ 40static int vmlinux_section_warnings = 1; 41/* Only warn about unresolved symbols */ 42static int warn_unresolved = 0; 43/* How a symbol is exported */ 44static int sec_mismatch_count = 0; 45static int sec_mismatch_verbose = 1; 46 47enum export { 48 export_plain, export_unused, export_gpl, 49 export_unused_gpl, export_gpl_future, export_unknown 50}; 51 52#define PRINTF __attribute__ ((format (printf, 1, 2))) 53 54PRINTF void fatal(const char *fmt, ...) 55{ 56 va_list arglist; 57 58 fprintf(stderr, "FATAL: "); 59 60 va_start(arglist, fmt); 61 vfprintf(stderr, fmt, arglist); 62 va_end(arglist); 63 64 exit(1); 65} 66 67PRINTF void warn(const char *fmt, ...) 68{ 69 va_list arglist; 70 71 fprintf(stderr, "WARNING: "); 72 73 va_start(arglist, fmt); 74 vfprintf(stderr, fmt, arglist); 75 va_end(arglist); 76} 77 78PRINTF void merror(const char *fmt, ...) 79{ 80 va_list arglist; 81 82 fprintf(stderr, "ERROR: "); 83 84 va_start(arglist, fmt); 85 vfprintf(stderr, fmt, arglist); 86 va_end(arglist); 87} 88 89static int is_vmlinux(const char *modname) 90{ 91 const char *myname; 92 93 myname = strrchr(modname, '/'); 94 if (myname) 95 myname++; 96 else 97 myname = modname; 98 99 return (strcmp(myname, "vmlinux") == 0) || 100 (strcmp(myname, "vmlinux.o") == 0); 101} 102 103void *do_nofail(void *ptr, const char *expr) 104{ 105 if (!ptr) 106 fatal("modpost: Memory allocation failure: %s.\n", expr); 107 108 return ptr; 109} 110 111/* A list of all modules we processed */ 112static struct module *modules; 113 114static struct module *find_module(char *modname) 115{ 116 struct module *mod; 117 118 for (mod = modules; mod; mod = mod->next) 119 if (strcmp(mod->name, modname) == 0) 120 break; 121 return mod; 122} 123 124static struct module *new_module(char *modname) 125{ 126 struct module *mod; 127 char *p, *s; 128 129 mod = NOFAIL(malloc(sizeof(*mod))); 130 memset(mod, 0, sizeof(*mod)); 131 p = NOFAIL(strdup(modname)); 132 133 /* strip trailing .o */ 134 s = strrchr(p, '.'); 135 if (s != NULL) 136 if (strcmp(s, ".o") == 0) 137 *s = '\0'; 138 139 /* add to list */ 140 mod->name = p; 141 mod->gpl_compatible = -1; 142 mod->next = modules; 143 modules = mod; 144 145 return mod; 146} 147 148/* A hash of all exported symbols, 149 * struct symbol is also used for lists of unresolved symbols */ 150 151#define SYMBOL_HASH_SIZE 1024 152 153struct symbol { 154 struct symbol *next; 155 struct module *module; 156 unsigned int crc; 157 int crc_valid; 158 unsigned int weak:1; 159 unsigned int vmlinux:1; /* 1 if symbol is defined in vmlinux */ 160 unsigned int kernel:1; /* 1 if symbol is from kernel 161 * (only for external modules) **/ 162 unsigned int preloaded:1; /* 1 if symbol from Module.symvers */ 163 enum export export; /* Type of export */ 164 char name[0]; 165}; 166 167static struct symbol *symbolhash[SYMBOL_HASH_SIZE]; 168 169/* This is based on the hash agorithm from gdbm, via tdb */ 170static inline unsigned int tdb_hash(const char *name) 171{ 172 unsigned value; /* Used to compute the hash value. */ 173 unsigned i; /* Used to cycle through random values. */ 174 175 /* Set the initial value from the key size. */ 176 for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++) 177 value = (value + (((unsigned char *)name)[i] << (i*5 % 24))); 178 179 return (1103515243 * value + 12345); 180} 181 182/** 183 * Allocate a new symbols for use in the hash of exported symbols or 184 * the list of unresolved symbols per module 185 **/ 186static struct symbol *alloc_symbol(const char *name, unsigned int weak, 187 struct symbol *next) 188{ 189 struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1)); 190 191 memset(s, 0, sizeof(*s)); 192 strcpy(s->name, name); 193 s->weak = weak; 194 s->next = next; 195 return s; 196} 197 198/* For the hash of exported symbols */ 199static struct symbol *new_symbol(const char *name, struct module *module, 200 enum export export) 201{ 202 unsigned int hash; 203 struct symbol *new; 204 205 hash = tdb_hash(name) % SYMBOL_HASH_SIZE; 206 new = symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]); 207 new->module = module; 208 new->export = export; 209 return new; 210} 211 212static struct symbol *find_symbol(const char *name) 213{ 214 struct symbol *s; 215 216 /* For our purposes, .foo matches foo. PPC64 needs this. */ 217 if (name[0] == '.') 218 name++; 219 220 for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) { 221 if (strcmp(s->name, name) == 0) 222 return s; 223 } 224 return NULL; 225} 226 227static struct { 228 const char *str; 229 enum export export; 230} export_list[] = { 231 { .str = "EXPORT_SYMBOL", .export = export_plain }, 232 { .str = "EXPORT_UNUSED_SYMBOL", .export = export_unused }, 233 { .str = "EXPORT_SYMBOL_GPL", .export = export_gpl }, 234 { .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl }, 235 { .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future }, 236 { .str = "(unknown)", .export = export_unknown }, 237}; 238 239 240static const char *export_str(enum export ex) 241{ 242 return export_list[ex].str; 243} 244 245static enum export export_no(const char *s) 246{ 247 int i; 248 249 if (!s) 250 return export_unknown; 251 for (i = 0; export_list[i].export != export_unknown; i++) { 252 if (strcmp(export_list[i].str, s) == 0) 253 return export_list[i].export; 254 } 255 return export_unknown; 256} 257 258static enum export export_from_sec(struct elf_info *elf, unsigned int sec) 259{ 260 if (sec == elf->export_sec) 261 return export_plain; 262 else if (sec == elf->export_unused_sec) 263 return export_unused; 264 else if (sec == elf->export_gpl_sec) 265 return export_gpl; 266 else if (sec == elf->export_unused_gpl_sec) 267 return export_unused_gpl; 268 else if (sec == elf->export_gpl_future_sec) 269 return export_gpl_future; 270 else 271 return export_unknown; 272} 273 274/** 275 * Add an exported symbol - it may have already been added without a 276 * CRC, in this case just update the CRC 277 **/ 278static struct symbol *sym_add_exported(const char *name, struct module *mod, 279 enum export export) 280{ 281 struct symbol *s = find_symbol(name); 282 283 if (!s) { 284 s = new_symbol(name, mod, export); 285 } else { 286 if (!s->preloaded) { 287 warn("%s: '%s' exported twice. Previous export " 288 "was in %s%s\n", mod->name, name, 289 s->module->name, 290 is_vmlinux(s->module->name) ?"":".ko"); 291 } else { 292 /* In case Modules.symvers was out of date */ 293 s->module = mod; 294 } 295 } 296 s->preloaded = 0; 297 s->vmlinux = is_vmlinux(mod->name); 298 s->kernel = 0; 299 s->export = export; 300 return s; 301} 302 303static void sym_update_crc(const char *name, struct module *mod, 304 unsigned int crc, enum export export) 305{ 306 struct symbol *s = find_symbol(name); 307 308 if (!s) 309 s = new_symbol(name, mod, export); 310 s->crc = crc; 311 s->crc_valid = 1; 312} 313 314void *grab_file(const char *filename, unsigned long *size) 315{ 316 struct stat st; 317 void *map; 318 int fd; 319 320 fd = open(filename, O_RDONLY); 321 if (fd < 0 || fstat(fd, &st) != 0) 322 return NULL; 323 324 *size = st.st_size; 325 map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0); 326 close(fd); 327 328 if (map == MAP_FAILED) 329 return NULL; 330 return map; 331} 332 333/** 334 * Return a copy of the next line in a mmap'ed file. 335 * spaces in the beginning of the line is trimmed away. 336 * Return a pointer to a static buffer. 337 **/ 338char *get_next_line(unsigned long *pos, void *file, unsigned long size) 339{ 340 static char line[4096]; 341 int skip = 1; 342 size_t len = 0; 343 signed char *p = (signed char *)file + *pos; 344 char *s = line; 345 346 for (; *pos < size ; (*pos)++) { 347 if (skip && isspace(*p)) { 348 p++; 349 continue; 350 } 351 skip = 0; 352 if (*p != '\n' && (*pos < size)) { 353 len++; 354 *s++ = *p++; 355 if (len > 4095) 356 break; /* Too long, stop */ 357 } else { 358 /* End of string */ 359 *s = '\0'; 360 return line; 361 } 362 } 363 /* End of buffer */ 364 return NULL; 365} 366 367void release_file(void *file, unsigned long size) 368{ 369 munmap(file, size); 370} 371 372static int parse_elf(struct elf_info *info, const char *filename) 373{ 374 unsigned int i; 375 Elf_Ehdr *hdr; 376 Elf_Shdr *sechdrs; 377 Elf_Sym *sym; 378 const char *secstrings; 379 unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U; 380 381 hdr = grab_file(filename, &info->size); 382 if (!hdr) { 383 perror(filename); 384 exit(1); 385 } 386 info->hdr = hdr; 387 if (info->size < sizeof(*hdr)) { 388 /* file too small, assume this is an empty .o file */ 389 return 0; 390 } 391 /* Is this a valid ELF file? */ 392 if ((hdr->e_ident[EI_MAG0] != ELFMAG0) || 393 (hdr->e_ident[EI_MAG1] != ELFMAG1) || 394 (hdr->e_ident[EI_MAG2] != ELFMAG2) || 395 (hdr->e_ident[EI_MAG3] != ELFMAG3)) { 396 /* Not an ELF file - silently ignore it */ 397 return 0; 398 } 399 /* Fix endianness in ELF header */ 400 hdr->e_type = TO_NATIVE(hdr->e_type); 401 hdr->e_machine = TO_NATIVE(hdr->e_machine); 402 hdr->e_version = TO_NATIVE(hdr->e_version); 403 hdr->e_entry = TO_NATIVE(hdr->e_entry); 404 hdr->e_phoff = TO_NATIVE(hdr->e_phoff); 405 hdr->e_shoff = TO_NATIVE(hdr->e_shoff); 406 hdr->e_flags = TO_NATIVE(hdr->e_flags); 407 hdr->e_ehsize = TO_NATIVE(hdr->e_ehsize); 408 hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize); 409 hdr->e_phnum = TO_NATIVE(hdr->e_phnum); 410 hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize); 411 hdr->e_shnum = TO_NATIVE(hdr->e_shnum); 412 hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx); 413 sechdrs = (void *)hdr + hdr->e_shoff; 414 info->sechdrs = sechdrs; 415 416 /* Check if file offset is correct */ 417 if (hdr->e_shoff > info->size) { 418 fatal("section header offset=%lu in file '%s' is bigger than " 419 "filesize=%lu\n", (unsigned long)hdr->e_shoff, 420 filename, info->size); 421 return 0; 422 } 423 424 if (hdr->e_shnum == 0) { 425 /* 426 * There are more than 64k sections, 427 * read count from .sh_size. 428 * note: it doesn't need shndx2secindex() 429 */ 430 info->num_sections = TO_NATIVE(sechdrs[0].sh_size); 431 } 432 else { 433 info->num_sections = hdr->e_shnum; 434 } 435 if (hdr->e_shstrndx == SHN_XINDEX) { 436 info->secindex_strings = 437 shndx2secindex(TO_NATIVE(sechdrs[0].sh_link)); 438 } 439 else { 440 info->secindex_strings = hdr->e_shstrndx; 441 } 442 443 /* Fix endianness in section headers */ 444 for (i = 0; i < info->num_sections; i++) { 445 sechdrs[i].sh_name = TO_NATIVE(sechdrs[i].sh_name); 446 sechdrs[i].sh_type = TO_NATIVE(sechdrs[i].sh_type); 447 sechdrs[i].sh_flags = TO_NATIVE(sechdrs[i].sh_flags); 448 sechdrs[i].sh_addr = TO_NATIVE(sechdrs[i].sh_addr); 449 sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset); 450 sechdrs[i].sh_size = TO_NATIVE(sechdrs[i].sh_size); 451 sechdrs[i].sh_link = TO_NATIVE(sechdrs[i].sh_link); 452 sechdrs[i].sh_info = TO_NATIVE(sechdrs[i].sh_info); 453 sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign); 454 sechdrs[i].sh_entsize = TO_NATIVE(sechdrs[i].sh_entsize); 455 } 456 /* Find symbol table. */ 457 secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset; 458 for (i = 1; i < info->num_sections; i++) { 459 const char *secname; 460 int nobits = sechdrs[i].sh_type == SHT_NOBITS; 461 462 if (!nobits && sechdrs[i].sh_offset > info->size) { 463 fatal("%s is truncated. sechdrs[i].sh_offset=%lu > " 464 "sizeof(*hrd)=%zu\n", filename, 465 (unsigned long)sechdrs[i].sh_offset, 466 sizeof(*hdr)); 467 return 0; 468 } 469 secname = secstrings + sechdrs[i].sh_name; 470 if (strcmp(secname, ".modinfo") == 0) { 471 if (nobits) 472 fatal("%s has NOBITS .modinfo\n", filename); 473 info->modinfo = (void *)hdr + sechdrs[i].sh_offset; 474 info->modinfo_len = sechdrs[i].sh_size; 475 } else if (strcmp(secname, "__ksymtab") == 0) 476 info->export_sec = i; 477 else if (strcmp(secname, "__ksymtab_unused") == 0) 478 info->export_unused_sec = i; 479 else if (strcmp(secname, "__ksymtab_gpl") == 0) 480 info->export_gpl_sec = i; 481 else if (strcmp(secname, "__ksymtab_unused_gpl") == 0) 482 info->export_unused_gpl_sec = i; 483 else if (strcmp(secname, "__ksymtab_gpl_future") == 0) 484 info->export_gpl_future_sec = i; 485 486 if (sechdrs[i].sh_type == SHT_SYMTAB) { 487 unsigned int sh_link_idx; 488 symtab_idx = i; 489 info->symtab_start = (void *)hdr + 490 sechdrs[i].sh_offset; 491 info->symtab_stop = (void *)hdr + 492 sechdrs[i].sh_offset + sechdrs[i].sh_size; 493 sh_link_idx = shndx2secindex(sechdrs[i].sh_link); 494 info->strtab = (void *)hdr + 495 sechdrs[sh_link_idx].sh_offset; 496 } 497 498 /* 32bit section no. table? ("more than 64k sections") */ 499 if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) { 500 symtab_shndx_idx = i; 501 info->symtab_shndx_start = (void *)hdr + 502 sechdrs[i].sh_offset; 503 info->symtab_shndx_stop = (void *)hdr + 504 sechdrs[i].sh_offset + sechdrs[i].sh_size; 505 } 506 } 507 if (!info->symtab_start) 508 fatal("%s has no symtab?\n", filename); 509 510 /* Fix endianness in symbols */ 511 for (sym = info->symtab_start; sym < info->symtab_stop; sym++) { 512 sym->st_shndx = TO_NATIVE(sym->st_shndx); 513 sym->st_name = TO_NATIVE(sym->st_name); 514 sym->st_value = TO_NATIVE(sym->st_value); 515 sym->st_size = TO_NATIVE(sym->st_size); 516 } 517 518 if (symtab_shndx_idx != ~0U) { 519 Elf32_Word *p; 520 if (symtab_idx != 521 shndx2secindex(sechdrs[symtab_shndx_idx].sh_link)) 522 fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n", 523 filename, 524 shndx2secindex(sechdrs[symtab_shndx_idx].sh_link), 525 symtab_idx); 526 /* Fix endianness */ 527 for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop; 528 p++) 529 *p = TO_NATIVE(*p); 530 } 531 532 return 1; 533} 534 535static void parse_elf_finish(struct elf_info *info) 536{ 537 release_file(info->hdr, info->size); 538} 539 540static int ignore_undef_symbol(struct elf_info *info, const char *symname) 541{ 542 /* ignore __this_module, it will be resolved shortly */ 543 if (strcmp(symname, MODULE_SYMBOL_PREFIX "__this_module") == 0) 544 return 1; 545 /* ignore global offset table */ 546 if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0) 547 return 1; 548 if (info->hdr->e_machine == EM_PPC) 549 /* Special register function linked on all modules during final link of .ko */ 550 if (strncmp(symname, "_restgpr_", sizeof("_restgpr_") - 1) == 0 || 551 strncmp(symname, "_savegpr_", sizeof("_savegpr_") - 1) == 0 || 552 strncmp(symname, "_rest32gpr_", sizeof("_rest32gpr_") - 1) == 0 || 553 strncmp(symname, "_save32gpr_", sizeof("_save32gpr_") - 1) == 0) 554 return 1; 555 if (info->hdr->e_machine == EM_PPC64) 556 /* Special register function linked on all modules during final link of .ko */ 557 if (strncmp(symname, "_restgpr0_", sizeof("_restgpr0_") - 1) == 0 || 558 strncmp(symname, "_savegpr0_", sizeof("_savegpr0_") - 1) == 0) 559 return 1; 560 /* Do not ignore this symbol */ 561 return 0; 562} 563 564#define CRC_PFX MODULE_SYMBOL_PREFIX "__crc_" 565#define KSYMTAB_PFX MODULE_SYMBOL_PREFIX "__ksymtab_" 566 567static void handle_modversions(struct module *mod, struct elf_info *info, 568 Elf_Sym *sym, const char *symname) 569{ 570 unsigned int crc; 571 enum export export = export_from_sec(info, get_secindex(info, sym)); 572 573 switch (sym->st_shndx) { 574 case SHN_COMMON: 575 warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name); 576 break; 577 case SHN_ABS: 578 /* CRC'd symbol */ 579 if (strncmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) { 580 crc = (unsigned int) sym->st_value; 581 sym_update_crc(symname + strlen(CRC_PFX), mod, crc, 582 export); 583 } 584 break; 585 case SHN_UNDEF: 586 /* undefined symbol */ 587 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL && 588 ELF_ST_BIND(sym->st_info) != STB_WEAK) 589 break; 590 if (ignore_undef_symbol(info, symname)) 591 break; 592/* cope with newer glibc (2.3.4 or higher) STT_ definition in elf.h */ 593#if defined(STT_REGISTER) || defined(STT_SPARC_REGISTER) 594/* add compatibility with older glibc */ 595#ifndef STT_SPARC_REGISTER 596#define STT_SPARC_REGISTER STT_REGISTER 597#endif 598 if (info->hdr->e_machine == EM_SPARC || 599 info->hdr->e_machine == EM_SPARCV9) { 600 /* Ignore register directives. */ 601 if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER) 602 break; 603 if (symname[0] == '.') { 604 char *munged = strdup(symname); 605 munged[0] = '_'; 606 munged[1] = toupper(munged[1]); 607 symname = munged; 608 } 609 } 610#endif 611 612 if (memcmp(symname, MODULE_SYMBOL_PREFIX, 613 strlen(MODULE_SYMBOL_PREFIX)) == 0) { 614 mod->unres = 615 alloc_symbol(symname + 616 strlen(MODULE_SYMBOL_PREFIX), 617 ELF_ST_BIND(sym->st_info) == STB_WEAK, 618 mod->unres); 619 } 620 break; 621 default: 622 /* All exported symbols */ 623 if (strncmp(symname, KSYMTAB_PFX, strlen(KSYMTAB_PFX)) == 0) { 624 sym_add_exported(symname + strlen(KSYMTAB_PFX), mod, 625 export); 626 } 627 if (strcmp(symname, MODULE_SYMBOL_PREFIX "init_module") == 0) 628 mod->has_init = 1; 629 if (strcmp(symname, MODULE_SYMBOL_PREFIX "cleanup_module") == 0) 630 mod->has_cleanup = 1; 631 break; 632 } 633} 634 635/** 636 * Parse tag=value strings from .modinfo section 637 **/ 638static char *next_string(char *string, unsigned long *secsize) 639{ 640 /* Skip non-zero chars */ 641 while (string[0]) { 642 string++; 643 if ((*secsize)-- <= 1) 644 return NULL; 645 } 646 647 /* Skip any zero padding. */ 648 while (!string[0]) { 649 string++; 650 if ((*secsize)-- <= 1) 651 return NULL; 652 } 653 return string; 654} 655 656static char *get_next_modinfo(void *modinfo, unsigned long modinfo_len, 657 const char *tag, char *info) 658{ 659 char *p; 660 unsigned int taglen = strlen(tag); 661 unsigned long size = modinfo_len; 662 663 if (info) { 664 size -= info - (char *)modinfo; 665 modinfo = next_string(info, &size); 666 } 667 668 for (p = modinfo; p; p = next_string(p, &size)) { 669 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=') 670 return p + taglen + 1; 671 } 672 return NULL; 673} 674 675static char *get_modinfo(void *modinfo, unsigned long modinfo_len, 676 const char *tag) 677 678{ 679 return get_next_modinfo(modinfo, modinfo_len, tag, NULL); 680} 681 682/** 683 * Test if string s ends in string sub 684 * return 0 if match 685 **/ 686static int strrcmp(const char *s, const char *sub) 687{ 688 int slen, sublen; 689 690 if (!s || !sub) 691 return 1; 692 693 slen = strlen(s); 694 sublen = strlen(sub); 695 696 if ((slen == 0) || (sublen == 0)) 697 return 1; 698 699 if (sublen > slen) 700 return 1; 701 702 return memcmp(s + slen - sublen, sub, sublen); 703} 704 705static const char *sym_name(struct elf_info *elf, Elf_Sym *sym) 706{ 707 if (sym) 708 return elf->strtab + sym->st_name; 709 else 710 return "(unknown)"; 711} 712 713static const char *sec_name(struct elf_info *elf, int secindex) 714{ 715 Elf_Shdr *sechdrs = elf->sechdrs; 716 return (void *)elf->hdr + 717 elf->sechdrs[elf->secindex_strings].sh_offset + 718 sechdrs[secindex].sh_name; 719} 720 721static const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr) 722{ 723 return (void *)elf->hdr + 724 elf->sechdrs[elf->secindex_strings].sh_offset + 725 sechdr->sh_name; 726} 727 728/* if sym is empty or point to a string 729 * like ".[0-9]+" then return 1. 730 * This is the optional prefix added by ld to some sections 731 */ 732static int number_prefix(const char *sym) 733{ 734 if (*sym++ == '\0') 735 return 1; 736 if (*sym != '.') 737 return 0; 738 do { 739 char c = *sym++; 740 if (c < '0' || c > '9') 741 return 0; 742 } while (*sym); 743 return 1; 744} 745 746/* The pattern is an array of simple patterns. 747 * "foo" will match an exact string equal to "foo" 748 * "*foo" will match a string that ends with "foo" 749 * "foo*" will match a string that begins with "foo" 750 * "foo$" will match a string equal to "foo" or "foo.1" 751 * where the '1' can be any number including several digits. 752 * The $ syntax is for sections where ld append a dot number 753 * to make section name unique. 754 */ 755static int match(const char *sym, const char * const pat[]) 756{ 757 const char *p; 758 while (*pat) { 759 p = *pat++; 760 const char *endp = p + strlen(p) - 1; 761 762 /* "*foo" */ 763 if (*p == '*') { 764 if (strrcmp(sym, p + 1) == 0) 765 return 1; 766 } 767 /* "foo*" */ 768 else if (*endp == '*') { 769 if (strncmp(sym, p, strlen(p) - 1) == 0) 770 return 1; 771 } 772 /* "foo$" */ 773 else if (*endp == '$') { 774 if (strncmp(sym, p, strlen(p) - 1) == 0) { 775 if (number_prefix(sym + strlen(p) - 1)) 776 return 1; 777 } 778 } 779 /* no wildcards */ 780 else { 781 if (strcmp(p, sym) == 0) 782 return 1; 783 } 784 } 785 /* no match */ 786 return 0; 787} 788 789/* sections that we do not want to do full section mismatch check on */ 790static const char *section_white_list[] = 791{ 792 ".comment*", 793 ".debug*", 794 ".GCC-command-line", /* mn10300 */ 795 ".mdebug*", /* alpha, score, mips etc. */ 796 ".pdr", /* alpha, score, mips etc. */ 797 ".stab*", 798 ".note*", 799 ".got*", 800 ".toc*", 801 NULL 802}; 803 804/* 805 * This is used to find sections missing the SHF_ALLOC flag. 806 * The cause of this is often a section specified in assembler 807 * without "ax" / "aw". 808 */ 809static void check_section(const char *modname, struct elf_info *elf, 810 Elf_Shdr *sechdr) 811{ 812 const char *sec = sech_name(elf, sechdr); 813 814 if (sechdr->sh_type == SHT_PROGBITS && 815 !(sechdr->sh_flags & SHF_ALLOC) && 816 !match(sec, section_white_list)) { 817 warn("%s (%s): unexpected non-allocatable section.\n" 818 "Did you forget to use \"ax\"/\"aw\" in a .S file?\n" 819 "Note that for example <linux/init.h> contains\n" 820 "section definitions for use in .S files.\n\n", 821 modname, sec); 822 } 823} 824 825 826 827#define ALL_INIT_DATA_SECTIONS \ 828 ".init.setup$", ".init.rodata$", \ 829 ".devinit.rodata$", ".cpuinit.rodata$", ".meminit.rodata$" \ 830 ".init.data$", ".devinit.data$", ".cpuinit.data$", ".meminit.data$" 831#define ALL_EXIT_DATA_SECTIONS \ 832 ".exit.data$", ".devexit.data$", ".cpuexit.data$", ".memexit.data$" 833 834#define ALL_INIT_TEXT_SECTIONS \ 835 ".init.text$", ".devinit.text$", ".cpuinit.text$", ".meminit.text$" 836#define ALL_EXIT_TEXT_SECTIONS \ 837 ".exit.text$", ".devexit.text$", ".cpuexit.text$", ".memexit.text$" 838 839#define ALL_XXXINIT_SECTIONS DEV_INIT_SECTIONS, CPU_INIT_SECTIONS, \ 840 MEM_INIT_SECTIONS 841#define ALL_XXXEXIT_SECTIONS DEV_EXIT_SECTIONS, CPU_EXIT_SECTIONS, \ 842 MEM_EXIT_SECTIONS 843 844#define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS 845#define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS 846 847#define DATA_SECTIONS ".data$", ".data.rel$" 848#define TEXT_SECTIONS ".text$" 849 850#define INIT_SECTIONS ".init.*" 851#define DEV_INIT_SECTIONS ".devinit.*" 852#define CPU_INIT_SECTIONS ".cpuinit.*" 853#define MEM_INIT_SECTIONS ".meminit.*" 854 855#define EXIT_SECTIONS ".exit.*" 856#define DEV_EXIT_SECTIONS ".devexit.*" 857#define CPU_EXIT_SECTIONS ".cpuexit.*" 858#define MEM_EXIT_SECTIONS ".memexit.*" 859 860/* init data sections */ 861static const char *init_data_sections[] = { ALL_INIT_DATA_SECTIONS, NULL }; 862 863/* all init sections */ 864static const char *init_sections[] = { ALL_INIT_SECTIONS, NULL }; 865 866/* All init and exit sections (code + data) */ 867static const char *init_exit_sections[] = 868 {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL }; 869 870/* data section */ 871static const char *data_sections[] = { DATA_SECTIONS, NULL }; 872 873 874/* symbols in .data that may refer to init/exit sections */ 875#define DEFAULT_SYMBOL_WHITE_LIST \ 876 "*driver", \ 877 "*_template", /* scsi uses *_template a lot */ \ 878 "*_timer", /* arm uses ops structures named _timer a lot */ \ 879 "*_sht", /* scsi also used *_sht to some extent */ \ 880 "*_ops", \ 881 "*_probe", \ 882 "*_probe_one", \ 883 "*_console" 884 885static const char *head_sections[] = { ".head.text*", NULL }; 886static const char *linker_symbols[] = 887 { "__init_begin", "_sinittext", "_einittext", NULL }; 888 889enum mismatch { 890 TEXT_TO_ANY_INIT, 891 DATA_TO_ANY_INIT, 892 TEXT_TO_ANY_EXIT, 893 DATA_TO_ANY_EXIT, 894 XXXINIT_TO_SOME_INIT, 895 XXXEXIT_TO_SOME_EXIT, 896 ANY_INIT_TO_ANY_EXIT, 897 ANY_EXIT_TO_ANY_INIT, 898 EXPORT_TO_INIT_EXIT, 899}; 900 901struct sectioncheck { 902 const char *fromsec[20]; 903 const char *tosec[20]; 904 enum mismatch mismatch; 905 const char *symbol_white_list[20]; 906}; 907 908const struct sectioncheck sectioncheck[] = { 909/* Do not reference init/exit code/data from 910 * normal code and data 911 */ 912{ 913 .fromsec = { TEXT_SECTIONS, NULL }, 914 .tosec = { ALL_INIT_SECTIONS, NULL }, 915 .mismatch = TEXT_TO_ANY_INIT, 916 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 917}, 918{ 919 .fromsec = { DATA_SECTIONS, NULL }, 920 .tosec = { ALL_XXXINIT_SECTIONS, NULL }, 921 .mismatch = DATA_TO_ANY_INIT, 922 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 923}, 924{ 925 .fromsec = { DATA_SECTIONS, NULL }, 926 .tosec = { INIT_SECTIONS, NULL }, 927 .mismatch = DATA_TO_ANY_INIT, 928 .symbol_white_list = { 929 "*_template", "*_timer", "*_sht", "*_ops", 930 "*_probe", "*_probe_one", "*_console", NULL 931 }, 932}, 933{ 934 .fromsec = { TEXT_SECTIONS, NULL }, 935 .tosec = { ALL_EXIT_SECTIONS, NULL }, 936 .mismatch = TEXT_TO_ANY_EXIT, 937 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 938}, 939{ 940 .fromsec = { DATA_SECTIONS, NULL }, 941 .tosec = { ALL_EXIT_SECTIONS, NULL }, 942 .mismatch = DATA_TO_ANY_EXIT, 943 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 944}, 945/* Do not reference init code/data from devinit/cpuinit/meminit code/data */ 946{ 947 .fromsec = { ALL_XXXINIT_SECTIONS, NULL }, 948 .tosec = { INIT_SECTIONS, NULL }, 949 .mismatch = XXXINIT_TO_SOME_INIT, 950 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 951}, 952/* Do not reference cpuinit code/data from meminit code/data */ 953{ 954 .fromsec = { MEM_INIT_SECTIONS, NULL }, 955 .tosec = { CPU_INIT_SECTIONS, NULL }, 956 .mismatch = XXXINIT_TO_SOME_INIT, 957 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 958}, 959/* Do not reference meminit code/data from cpuinit code/data */ 960{ 961 .fromsec = { CPU_INIT_SECTIONS, NULL }, 962 .tosec = { MEM_INIT_SECTIONS, NULL }, 963 .mismatch = XXXINIT_TO_SOME_INIT, 964 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 965}, 966/* Do not reference exit code/data from devexit/cpuexit/memexit code/data */ 967{ 968 .fromsec = { ALL_XXXEXIT_SECTIONS, NULL }, 969 .tosec = { EXIT_SECTIONS, NULL }, 970 .mismatch = XXXEXIT_TO_SOME_EXIT, 971 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 972}, 973/* Do not reference cpuexit code/data from memexit code/data */ 974{ 975 .fromsec = { MEM_EXIT_SECTIONS, NULL }, 976 .tosec = { CPU_EXIT_SECTIONS, NULL }, 977 .mismatch = XXXEXIT_TO_SOME_EXIT, 978 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 979}, 980/* Do not reference memexit code/data from cpuexit code/data */ 981{ 982 .fromsec = { CPU_EXIT_SECTIONS, NULL }, 983 .tosec = { MEM_EXIT_SECTIONS, NULL }, 984 .mismatch = XXXEXIT_TO_SOME_EXIT, 985 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 986}, 987/* Do not use exit code/data from init code */ 988{ 989 .fromsec = { ALL_INIT_SECTIONS, NULL }, 990 .tosec = { ALL_EXIT_SECTIONS, NULL }, 991 .mismatch = ANY_INIT_TO_ANY_EXIT, 992 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 993}, 994/* Do not use init code/data from exit code */ 995{ 996 .fromsec = { ALL_EXIT_SECTIONS, NULL }, 997 .tosec = { ALL_INIT_SECTIONS, NULL }, 998 .mismatch = ANY_EXIT_TO_ANY_INIT, 999 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 1000}, 1001/* Do not export init/exit functions or data */ 1002{ 1003 .fromsec = { "__ksymtab*", NULL }, 1004 .tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL }, 1005 .mismatch = EXPORT_TO_INIT_EXIT, 1006 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL }, 1007} 1008}; 1009 1010static const struct sectioncheck *section_mismatch( 1011 const char *fromsec, const char *tosec) 1012{ 1013 int i; 1014 int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck); 1015 const struct sectioncheck *check = §ioncheck[0]; 1016 1017 for (i = 0; i < elems; i++) { 1018 if (match(fromsec, check->fromsec) && 1019 match(tosec, check->tosec)) 1020 return check; 1021 check++; 1022 } 1023 return NULL; 1024} 1025 1026/** 1027 * Whitelist to allow certain references to pass with no warning. 1028 * 1029 * Pattern 1: 1030 * If a module parameter is declared __initdata and permissions=0 1031 * then this is legal despite the warning generated. 1032 * We cannot see value of permissions here, so just ignore 1033 * this pattern. 1034 * The pattern is identified by: 1035 * tosec = .init.data 1036 * fromsec = .data* 1037 * atsym =__param* 1038 * 1039 * Pattern 1a: 1040 * module_param_call() ops can refer to __init set function if permissions=0 1041 * The pattern is identified by: 1042 * tosec = .init.text 1043 * fromsec = .data* 1044 * atsym = __param_ops_* 1045 * 1046 * Pattern 2: 1047 * Many drivers utilise a *driver container with references to 1048 * add, remove, probe functions etc. 1049 * These functions may often be marked __devinit and we do not want to 1050 * warn here. 1051 * the pattern is identified by: 1052 * tosec = init or exit section 1053 * fromsec = data section 1054 * atsym = *driver, *_template, *_sht, *_ops, *_probe, 1055 * *probe_one, *_console, *_timer 1056 * 1057 * Pattern 3: 1058 * Whitelist all references from .head.text to any init section 1059 * 1060 * Pattern 4: 1061 * Some symbols belong to init section but still it is ok to reference 1062 * these from non-init sections as these symbols don't have any memory 1063 * allocated for them and symbol address and value are same. So even 1064 * if init section is freed, its ok to reference those symbols. 1065 * For ex. symbols marking the init section boundaries. 1066 * This pattern is identified by 1067 * refsymname = __init_begin, _sinittext, _einittext 1068 * 1069 **/ 1070static int secref_whitelist(const struct sectioncheck *mismatch, 1071 const char *fromsec, const char *fromsym, 1072 const char *tosec, const char *tosym) 1073{ 1074 /* Check for pattern 1 */ 1075 if (match(tosec, init_data_sections) && 1076 match(fromsec, data_sections) && 1077 (strncmp(fromsym, "__param", strlen("__param")) == 0)) 1078 return 0; 1079 1080 /* Check for pattern 1a */ 1081 if (strcmp(tosec, ".init.text") == 0 && 1082 match(fromsec, data_sections) && 1083 (strncmp(fromsym, "__param_ops_", strlen("__param_ops_")) == 0)) 1084 return 0; 1085 1086 /* Check for pattern 2 */ 1087 if (match(tosec, init_exit_sections) && 1088 match(fromsec, data_sections) && 1089 match(fromsym, mismatch->symbol_white_list)) 1090 return 0; 1091 1092 /* Check for pattern 3 */ 1093 if (match(fromsec, head_sections) && 1094 match(tosec, init_sections)) 1095 return 0; 1096 1097 /* Check for pattern 4 */ 1098 if (match(tosym, linker_symbols)) 1099 return 0; 1100 1101 return 1; 1102} 1103 1104/** 1105 * Find symbol based on relocation record info. 1106 * In some cases the symbol supplied is a valid symbol so 1107 * return refsym. If st_name != 0 we assume this is a valid symbol. 1108 * In other cases the symbol needs to be looked up in the symbol table 1109 * based on section and address. 1110 * **/ 1111static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr, 1112 Elf_Sym *relsym) 1113{ 1114 Elf_Sym *sym; 1115 Elf_Sym *near = NULL; 1116 Elf64_Sword distance = 20; 1117 Elf64_Sword d; 1118 unsigned int relsym_secindex; 1119 1120 if (relsym->st_name != 0) 1121 return relsym; 1122 1123 relsym_secindex = get_secindex(elf, relsym); 1124 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) { 1125 if (get_secindex(elf, sym) != relsym_secindex) 1126 continue; 1127 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION) 1128 continue; 1129 if (sym->st_value == addr) 1130 return sym; 1131 /* Find a symbol nearby - addr are maybe negative */ 1132 d = sym->st_value - addr; 1133 if (d < 0) 1134 d = addr - sym->st_value; 1135 if (d < distance) { 1136 distance = d; 1137 near = sym; 1138 } 1139 } 1140 /* We need a close match */ 1141 if (distance < 20) 1142 return near; 1143 else 1144 return NULL; 1145} 1146 1147static inline int is_arm_mapping_symbol(const char *str) 1148{ 1149 return str[0] == '$' && strchr("atd", str[1]) 1150 && (str[2] == '\0' || str[2] == '.'); 1151} 1152 1153/* 1154 * If there's no name there, ignore it; likewise, ignore it if it's 1155 * one of the magic symbols emitted used by current ARM tools. 1156 * 1157 * Otherwise if find_symbols_between() returns those symbols, they'll 1158 * fail the whitelist tests and cause lots of false alarms ... fixable 1159 * only by merging __exit and __init sections into __text, bloating 1160 * the kernel (which is especially evil on embedded platforms). 1161 */ 1162static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym) 1163{ 1164 const char *name = elf->strtab + sym->st_name; 1165 1166 if (!name || !strlen(name)) 1167 return 0; 1168 return !is_arm_mapping_symbol(name); 1169} 1170 1171/* 1172 * Find symbols before or equal addr and after addr - in the section sec. 1173 * If we find two symbols with equal offset prefer one with a valid name. 1174 * The ELF format may have a better way to detect what type of symbol 1175 * it is, but this works for now. 1176 **/ 1177static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr, 1178 const char *sec) 1179{ 1180 Elf_Sym *sym; 1181 Elf_Sym *near = NULL; 1182 Elf_Addr distance = ~0; 1183 1184 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) { 1185 const char *symsec; 1186 1187 if (is_shndx_special(sym->st_shndx)) 1188 continue; 1189 symsec = sec_name(elf, get_secindex(elf, sym)); 1190 if (strcmp(symsec, sec) != 0) 1191 continue; 1192 if (!is_valid_name(elf, sym)) 1193 continue; 1194 if (sym->st_value <= addr) { 1195 if ((addr - sym->st_value) < distance) { 1196 distance = addr - sym->st_value; 1197 near = sym; 1198 } else if ((addr - sym->st_value) == distance) { 1199 near = sym; 1200 } 1201 } 1202 } 1203 return near; 1204} 1205 1206/* 1207 * Convert a section name to the function/data attribute 1208 * .init.text => __init 1209 * .cpuinit.data => __cpudata 1210 * .memexitconst => __memconst 1211 * etc. 1212*/ 1213static char *sec2annotation(const char *s) 1214{ 1215 if (match(s, init_exit_sections)) { 1216 char *p = malloc(20); 1217 char *r = p; 1218 1219 *p++ = '_'; 1220 *p++ = '_'; 1221 if (*s == '.') 1222 s++; 1223 while (*s && *s != '.') 1224 *p++ = *s++; 1225 *p = '\0'; 1226 if (*s == '.') 1227 s++; 1228 if (strstr(s, "rodata") != NULL) 1229 strcat(p, "const "); 1230 else if (strstr(s, "data") != NULL) 1231 strcat(p, "data "); 1232 else 1233 strcat(p, " "); 1234 return r; /* we leak her but we do not care */ 1235 } else { 1236 return strdup(""); 1237 } 1238} 1239 1240static int is_function(Elf_Sym *sym) 1241{ 1242 if (sym) 1243 return ELF_ST_TYPE(sym->st_info) == STT_FUNC; 1244 else 1245 return -1; 1246} 1247 1248/* 1249 * Print a warning about a section mismatch. 1250 * Try to find symbols near it so user can find it. 1251 * Check whitelist before warning - it may be a false positive. 1252 */ 1253static void report_sec_mismatch(const char *modname, 1254 const struct sectioncheck *mismatch, 1255 const char *fromsec, 1256 unsigned long long fromaddr, 1257 const char *fromsym, 1258 int from_is_func, 1259 const char *tosec, const char *tosym, 1260 int to_is_func) 1261{ 1262 const char *from, *from_p; 1263 const char *to, *to_p; 1264 char *prl_from; 1265 char *prl_to; 1266 1267 switch (from_is_func) { 1268 case 0: from = "variable"; from_p = ""; break; 1269 case 1: from = "function"; from_p = "()"; break; 1270 default: from = "(unknown reference)"; from_p = ""; break; 1271 } 1272 switch (to_is_func) { 1273 case 0: to = "variable"; to_p = ""; break; 1274 case 1: to = "function"; to_p = "()"; break; 1275 default: to = "(unknown reference)"; to_p = ""; break; 1276 } 1277 1278 sec_mismatch_count++; 1279 if (!sec_mismatch_verbose) 1280 return; 1281 1282 warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s " 1283 "to the %s %s:%s%s\n", 1284 modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec, 1285 tosym, to_p); 1286 1287 switch (mismatch->mismatch) { 1288 case TEXT_TO_ANY_INIT: 1289 prl_from = sec2annotation(fromsec); 1290 prl_to = sec2annotation(tosec); 1291 fprintf(stderr, 1292 "The function %s%s() references\n" 1293 "the %s %s%s%s.\n" 1294 "This is often because %s lacks a %s\n" 1295 "annotation or the annotation of %s is wrong.\n", 1296 prl_from, fromsym, 1297 to, prl_to, tosym, to_p, 1298 fromsym, prl_to, tosym); 1299 free(prl_from); 1300 free(prl_to); 1301 break; 1302 case DATA_TO_ANY_INIT: { 1303 prl_to = sec2annotation(tosec); 1304 const char *const *s = mismatch->symbol_white_list; 1305 fprintf(stderr, 1306 "The variable %s references\n" 1307 "the %s %s%s%s\n" 1308 "If the reference is valid then annotate the\n" 1309 "variable with __init* or __refdata (see linux/init.h) " 1310 "or name the variable:\n", 1311 fromsym, to, prl_to, tosym, to_p); 1312 while (*s) 1313 fprintf(stderr, "%s, ", *s++); 1314 fprintf(stderr, "\n"); 1315 free(prl_to); 1316 break; 1317 } 1318 case TEXT_TO_ANY_EXIT: 1319 prl_to = sec2annotation(tosec); 1320 fprintf(stderr, 1321 "The function %s() references a %s in an exit section.\n" 1322 "Often the %s %s%s has valid usage outside the exit section\n" 1323 "and the fix is to remove the %sannotation of %s.\n", 1324 fromsym, to, to, tosym, to_p, prl_to, tosym); 1325 free(prl_to); 1326 break; 1327 case DATA_TO_ANY_EXIT: { 1328 prl_to = sec2annotation(tosec); 1329 const char *const *s = mismatch->symbol_white_list; 1330 fprintf(stderr, 1331 "The variable %s references\n" 1332 "the %s %s%s%s\n" 1333 "If the reference is valid then annotate the\n" 1334 "variable with __exit* (see linux/init.h) or " 1335 "name the variable:\n", 1336 fromsym, to, prl_to, tosym, to_p); 1337 while (*s) 1338 fprintf(stderr, "%s, ", *s++); 1339 fprintf(stderr, "\n"); 1340 free(prl_to); 1341 break; 1342 } 1343 case XXXINIT_TO_SOME_INIT: 1344 case XXXEXIT_TO_SOME_EXIT: 1345 prl_from = sec2annotation(fromsec); 1346 prl_to = sec2annotation(tosec); 1347 fprintf(stderr, 1348 "The %s %s%s%s references\n" 1349 "a %s %s%s%s.\n" 1350 "If %s is only used by %s then\n" 1351 "annotate %s with a matching annotation.\n", 1352 from, prl_from, fromsym, from_p, 1353 to, prl_to, tosym, to_p, 1354 tosym, fromsym, tosym); 1355 free(prl_from); 1356 free(prl_to); 1357 break; 1358 case ANY_INIT_TO_ANY_EXIT: 1359 prl_from = sec2annotation(fromsec); 1360 prl_to = sec2annotation(tosec); 1361 fprintf(stderr, 1362 "The %s %s%s%s references\n" 1363 "a %s %s%s%s.\n" 1364 "This is often seen when error handling " 1365 "in the init function\n" 1366 "uses functionality in the exit path.\n" 1367 "The fix is often to remove the %sannotation of\n" 1368 "%s%s so it may be used outside an exit section.\n", 1369 from, prl_from, fromsym, from_p, 1370 to, prl_to, tosym, to_p, 1371 prl_to, tosym, to_p); 1372 free(prl_from); 1373 free(prl_to); 1374 break; 1375 case ANY_EXIT_TO_ANY_INIT: 1376 prl_from = sec2annotation(fromsec); 1377 prl_to = sec2annotation(tosec); 1378 fprintf(stderr, 1379 "The %s %s%s%s references\n" 1380 "a %s %s%s%s.\n" 1381 "This is often seen when error handling " 1382 "in the exit function\n" 1383 "uses functionality in the init path.\n" 1384 "The fix is often to remove the %sannotation of\n" 1385 "%s%s so it may be used outside an init section.\n", 1386 from, prl_from, fromsym, from_p, 1387 to, prl_to, tosym, to_p, 1388 prl_to, tosym, to_p); 1389 free(prl_from); 1390 free(prl_to); 1391 break; 1392 case EXPORT_TO_INIT_EXIT: 1393 prl_to = sec2annotation(tosec); 1394 fprintf(stderr, 1395 "The symbol %s is exported and annotated %s\n" 1396 "Fix this by removing the %sannotation of %s " 1397 "or drop the export.\n", 1398 tosym, prl_to, prl_to, tosym); 1399 free(prl_to); 1400 break; 1401 } 1402 fprintf(stderr, "\n"); 1403} 1404 1405static void check_section_mismatch(const char *modname, struct elf_info *elf, 1406 Elf_Rela *r, Elf_Sym *sym, const char *fromsec) 1407{ 1408 const char *tosec; 1409 const struct sectioncheck *mismatch; 1410 1411 tosec = sec_name(elf, get_secindex(elf, sym)); 1412 mismatch = section_mismatch(fromsec, tosec); 1413 if (mismatch) { 1414 Elf_Sym *to; 1415 Elf_Sym *from; 1416 const char *tosym; 1417 const char *fromsym; 1418 1419 from = find_elf_symbol2(elf, r->r_offset, fromsec); 1420 fromsym = sym_name(elf, from); 1421 to = find_elf_symbol(elf, r->r_addend, sym); 1422 tosym = sym_name(elf, to); 1423 1424 /* check whitelist - we may ignore it */ 1425 if (secref_whitelist(mismatch, 1426 fromsec, fromsym, tosec, tosym)) { 1427 report_sec_mismatch(modname, mismatch, 1428 fromsec, r->r_offset, fromsym, 1429 is_function(from), tosec, tosym, 1430 is_function(to)); 1431 } 1432 } 1433} 1434 1435static unsigned int *reloc_location(struct elf_info *elf, 1436 Elf_Shdr *sechdr, Elf_Rela *r) 1437{ 1438 Elf_Shdr *sechdrs = elf->sechdrs; 1439 int section = shndx2secindex(sechdr->sh_info); 1440 1441 return (void *)elf->hdr + sechdrs[section].sh_offset + 1442 r->r_offset - sechdrs[section].sh_addr; 1443} 1444 1445static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r) 1446{ 1447 unsigned int r_typ = ELF_R_TYPE(r->r_info); 1448 unsigned int *location = reloc_location(elf, sechdr, r); 1449 1450 switch (r_typ) { 1451 case R_386_32: 1452 r->r_addend = TO_NATIVE(*location); 1453 break; 1454 case R_386_PC32: 1455 r->r_addend = TO_NATIVE(*location) + 4; 1456 /* For CONFIG_RELOCATABLE=y */ 1457 if (elf->hdr->e_type == ET_EXEC) 1458 r->r_addend += r->r_offset; 1459 break; 1460 } 1461 return 0; 1462} 1463 1464static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r) 1465{ 1466 unsigned int r_typ = ELF_R_TYPE(r->r_info); 1467 1468 switch (r_typ) { 1469 case R_ARM_ABS32: 1470 /* From ARM ABI: (S + A) | T */ 1471 r->r_addend = (int)(long) 1472 (elf->symtab_start + ELF_R_SYM(r->r_info)); 1473 break; 1474 case R_ARM_PC24: 1475 /* From ARM ABI: ((S + A) | T) - P */ 1476 r->r_addend = (int)(long)(elf->hdr + 1477 sechdr->sh_offset + 1478 (r->r_offset - sechdr->sh_addr)); 1479 break; 1480 default: 1481 return 1; 1482 } 1483 return 0; 1484} 1485 1486static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r) 1487{ 1488 unsigned int r_typ = ELF_R_TYPE(r->r_info); 1489 unsigned int *location = reloc_location(elf, sechdr, r); 1490 unsigned int inst; 1491 1492 if (r_typ == R_MIPS_HI16) 1493 return 1; /* skip this */ 1494 inst = TO_NATIVE(*location); 1495 switch (r_typ) { 1496 case R_MIPS_LO16: 1497 r->r_addend = inst & 0xffff; 1498 break; 1499 case R_MIPS_26: 1500 r->r_addend = (inst & 0x03ffffff) << 2; 1501 break; 1502 case R_MIPS_32: 1503 r->r_addend = inst; 1504 break; 1505 } 1506 return 0; 1507} 1508 1509static void section_rela(const char *modname, struct elf_info *elf, 1510 Elf_Shdr *sechdr) 1511{ 1512 Elf_Sym *sym; 1513 Elf_Rela *rela; 1514 Elf_Rela r; 1515 unsigned int r_sym; 1516 const char *fromsec; 1517 1518 Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset; 1519 Elf_Rela *stop = (void *)start + sechdr->sh_size; 1520 1521 fromsec = sech_name(elf, sechdr); 1522 fromsec += strlen(".rela"); 1523 /* if from section (name) is know good then skip it */ 1524 if (match(fromsec, section_white_list)) 1525 return; 1526 1527 for (rela = start; rela < stop; rela++) { 1528 r.r_offset = TO_NATIVE(rela->r_offset); 1529#if KERNEL_ELFCLASS == ELFCLASS64 1530 if (elf->hdr->e_machine == EM_MIPS) { 1531 unsigned int r_typ; 1532 r_sym = ELF64_MIPS_R_SYM(rela->r_info); 1533 r_sym = TO_NATIVE(r_sym); 1534 r_typ = ELF64_MIPS_R_TYPE(rela->r_info); 1535 r.r_info = ELF64_R_INFO(r_sym, r_typ); 1536 } else { 1537 r.r_info = TO_NATIVE(rela->r_info); 1538 r_sym = ELF_R_SYM(r.r_info); 1539 } 1540#else 1541 r.r_info = TO_NATIVE(rela->r_info); 1542 r_sym = ELF_R_SYM(r.r_info); 1543#endif 1544 r.r_addend = TO_NATIVE(rela->r_addend); 1545 sym = elf->symtab_start + r_sym; 1546 /* Skip special sections */ 1547 if (is_shndx_special(sym->st_shndx)) 1548 continue; 1549 check_section_mismatch(modname, elf, &r, sym, fromsec); 1550 } 1551} 1552 1553static void section_rel(const char *modname, struct elf_info *elf, 1554 Elf_Shdr *sechdr) 1555{ 1556 Elf_Sym *sym; 1557 Elf_Rel *rel; 1558 Elf_Rela r; 1559 unsigned int r_sym; 1560 const char *fromsec; 1561 1562 Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset; 1563 Elf_Rel *stop = (void *)start + sechdr->sh_size; 1564 1565 fromsec = sech_name(elf, sechdr); 1566 fromsec += strlen(".rel"); 1567 /* if from section (name) is know good then skip it */ 1568 if (match(fromsec, section_white_list)) 1569 return; 1570 1571 for (rel = start; rel < stop; rel++) { 1572 r.r_offset = TO_NATIVE(rel->r_offset); 1573#if KERNEL_ELFCLASS == ELFCLASS64 1574 if (elf->hdr->e_machine == EM_MIPS) { 1575 unsigned int r_typ; 1576 r_sym = ELF64_MIPS_R_SYM(rel->r_info); 1577 r_sym = TO_NATIVE(r_sym); 1578 r_typ = ELF64_MIPS_R_TYPE(rel->r_info); 1579 r.r_info = ELF64_R_INFO(r_sym, r_typ); 1580 } else { 1581 r.r_info = TO_NATIVE(rel->r_info); 1582 r_sym = ELF_R_SYM(r.r_info); 1583 } 1584#else 1585 r.r_info = TO_NATIVE(rel->r_info); 1586 r_sym = ELF_R_SYM(r.r_info); 1587#endif 1588 r.r_addend = 0; 1589 switch (elf->hdr->e_machine) { 1590 case EM_386: 1591 if (addend_386_rel(elf, sechdr, &r)) 1592 continue; 1593 break; 1594 case EM_ARM: 1595 if (addend_arm_rel(elf, sechdr, &r)) 1596 continue; 1597 break; 1598 case EM_MIPS: 1599 if (addend_mips_rel(elf, sechdr, &r)) 1600 continue; 1601 break; 1602 } 1603 sym = elf->symtab_start + r_sym; 1604 /* Skip special sections */ 1605 if (is_shndx_special(sym->st_shndx)) 1606 continue; 1607 check_section_mismatch(modname, elf, &r, sym, fromsec); 1608 } 1609} 1610 1611/** 1612 * A module includes a number of sections that are discarded 1613 * either when loaded or when used as built-in. 1614 * For loaded modules all functions marked __init and all data 1615 * marked __initdata will be discarded when the module has been intialized. 1616 * Likewise for modules used built-in the sections marked __exit 1617 * are discarded because __exit marked function are supposed to be called 1618 * only when a module is unloaded which never happens for built-in modules. 1619 * The check_sec_ref() function traverses all relocation records 1620 * to find all references to a section that reference a section that will 1621 * be discarded and warns about it. 1622 **/ 1623static void check_sec_ref(struct module *mod, const char *modname, 1624 struct elf_info *elf) 1625{ 1626 int i; 1627 Elf_Shdr *sechdrs = elf->sechdrs; 1628 1629 /* Walk through all sections */ 1630 for (i = 0; i < elf->num_sections; i++) { 1631 check_section(modname, elf, &elf->sechdrs[i]); 1632 /* We want to process only relocation sections and not .init */ 1633 if (sechdrs[i].sh_type == SHT_RELA) 1634 section_rela(modname, elf, &elf->sechdrs[i]); 1635 else if (sechdrs[i].sh_type == SHT_REL) 1636 section_rel(modname, elf, &elf->sechdrs[i]); 1637 } 1638} 1639 1640static void read_symbols(char *modname) 1641{ 1642 const char *symname; 1643 char *version; 1644 char *license; 1645 struct module *mod; 1646 struct elf_info info = { }; 1647 Elf_Sym *sym; 1648 1649 if (!parse_elf(&info, modname)) 1650 return; 1651 1652 mod = new_module(modname); 1653 1654 /* When there's no vmlinux, don't print warnings about 1655 * unresolved symbols (since there'll be too many ;) */ 1656 if (is_vmlinux(modname)) { 1657 have_vmlinux = 1; 1658 mod->skip = 1; 1659 } 1660 1661 license = get_modinfo(info.modinfo, info.modinfo_len, "license"); 1662 if (info.modinfo && !license && !is_vmlinux(modname)) 1663 warn("modpost: missing MODULE_LICENSE() in %s\n" 1664 "see include/linux/module.h for " 1665 "more information\n", modname); 1666 while (license) { 1667 if (license_is_gpl_compatible(license)) 1668 mod->gpl_compatible = 1; 1669 else { 1670 mod->gpl_compatible = 0; 1671 break; 1672 } 1673 license = get_next_modinfo(info.modinfo, info.modinfo_len, 1674 "license", license); 1675 } 1676 1677 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) { 1678 symname = info.strtab + sym->st_name; 1679 1680 handle_modversions(mod, &info, sym, symname); 1681 handle_moddevtable(mod, &info, sym, symname); 1682 } 1683 if (!is_vmlinux(modname) || 1684 (is_vmlinux(modname) && vmlinux_section_warnings)) 1685 check_sec_ref(mod, modname, &info); 1686 1687 version = get_modinfo(info.modinfo, info.modinfo_len, "version"); 1688 if (version) 1689 maybe_frob_rcs_version(modname, version, info.modinfo, 1690 version - (char *)info.hdr); 1691 if (version || (all_versions && !is_vmlinux(modname))) 1692 get_src_version(modname, mod->srcversion, 1693 sizeof(mod->srcversion)-1); 1694 1695 parse_elf_finish(&info); 1696 1697 /* Our trick to get versioning for module struct etc. - it's 1698 * never passed as an argument to an exported function, so 1699 * the automatic versioning doesn't pick it up, but it's really 1700 * important anyhow */ 1701 if (modversions) 1702 mod->unres = alloc_symbol("module_layout", 0, mod->unres); 1703} 1704 1705#define SZ 500 1706 1707/* We first write the generated file into memory using the 1708 * following helper, then compare to the file on disk and 1709 * only update the later if anything changed */ 1710 1711void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf, 1712 const char *fmt, ...) 1713{ 1714 char tmp[SZ]; 1715 int len; 1716 va_list ap; 1717 1718 va_start(ap, fmt); 1719 len = vsnprintf(tmp, SZ, fmt, ap); 1720 buf_write(buf, tmp, len); 1721 va_end(ap); 1722} 1723 1724void buf_write(struct buffer *buf, const char *s, int len) 1725{ 1726 if (buf->size - buf->pos < len) { 1727 buf->size += len + SZ; 1728 buf->p = realloc(buf->p, buf->size); 1729 } 1730 strncpy(buf->p + buf->pos, s, len); 1731 buf->pos += len; 1732} 1733 1734static void check_for_gpl_usage(enum export exp, const char *m, const char *s) 1735{ 1736 const char *e = is_vmlinux(m) ?"":".ko"; 1737 1738 switch (exp) { 1739 case export_gpl: 1740 warn("modpost: GPL-incompatible module %s%s " 1741 "uses GPL-only symbol '%s'\n", m, e, s); 1742 break; 1743 case export_unused_gpl: 1744 warn("modpost: GPL-incompatible module %s%s " 1745 "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s); 1746 break; 1747 case export_gpl_future: 1748 warn("modpost: GPL-incompatible module %s%s " 1749 "uses future GPL-only symbol '%s'\n", m, e, s); 1750 break; 1751 case export_plain: 1752 case export_unused: 1753 case export_unknown: 1754 /* ignore */ 1755 break; 1756 } 1757} 1758 1759static void check_for_unused(enum export exp, const char *m, const char *s) 1760{ 1761 const char *e = is_vmlinux(m) ?"":".ko"; 1762 1763 switch (exp) { 1764 case export_unused: 1765 case export_unused_gpl: 1766 warn("modpost: module %s%s " 1767 "uses symbol '%s' marked UNUSED\n", m, e, s); 1768 break; 1769 default: 1770 /* ignore */ 1771 break; 1772 } 1773} 1774 1775static void check_exports(struct module *mod) 1776{ 1777 struct symbol *s, *exp; 1778 1779 for (s = mod->unres; s; s = s->next) { 1780 const char *basename; 1781 exp = find_symbol(s->name); 1782 if (!exp || exp->module == mod) 1783 continue; 1784 basename = strrchr(mod->name, '/'); 1785 if (basename) 1786 basename++; 1787 else 1788 basename = mod->name; 1789 if (!mod->gpl_compatible) 1790 check_for_gpl_usage(exp->export, basename, exp->name); 1791 check_for_unused(exp->export, basename, exp->name); 1792 } 1793} 1794 1795/** 1796 * Header for the generated file 1797 **/ 1798static void add_header(struct buffer *b, struct module *mod) 1799{ 1800 buf_printf(b, "#include <linux/module.h>\n"); 1801 buf_printf(b, "#include <linux/vermagic.h>\n"); 1802 buf_printf(b, "#include <linux/compiler.h>\n"); 1803 buf_printf(b, "\n"); 1804 buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n"); 1805 buf_printf(b, "\n"); 1806 buf_printf(b, "struct module __this_module\n"); 1807 buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n"); 1808 buf_printf(b, " .name = KBUILD_MODNAME,\n"); 1809 if (mod->has_init) 1810 buf_printf(b, " .init = init_module,\n"); 1811 if (mod->has_cleanup) 1812 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n" 1813 " .exit = cleanup_module,\n" 1814 "#endif\n"); 1815 buf_printf(b, " .arch = MODULE_ARCH_INIT,\n"); 1816 buf_printf(b, "};\n"); 1817} 1818 1819static void add_staging_flag(struct buffer *b, const char *name) 1820{ 1821 static const char *staging_dir = "drivers/staging"; 1822 1823 if (strncmp(staging_dir, name, strlen(staging_dir)) == 0) 1824 buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n"); 1825} 1826 1827/** 1828 * Record CRCs for unresolved symbols 1829 **/ 1830static int add_versions(struct buffer *b, struct module *mod) 1831{ 1832 struct symbol *s, *exp; 1833 int err = 0; 1834 1835 for (s = mod->unres; s; s = s->next) { 1836 exp = find_symbol(s->name); 1837 if (!exp || exp->module == mod) { 1838 if (have_vmlinux && !s->weak) { 1839 if (warn_unresolved) { 1840 warn("\"%s\" [%s.ko] undefined!\n", 1841 s->name, mod->name); 1842 } else { 1843 merror("\"%s\" [%s.ko] undefined!\n", 1844 s->name, mod->name); 1845 err = 1; 1846 } 1847 } 1848 continue; 1849 } 1850 s->module = exp->module; 1851 s->crc_valid = exp->crc_valid; 1852 s->crc = exp->crc; 1853 } 1854 1855 if (!modversions) 1856 return err; 1857 1858 buf_printf(b, "\n"); 1859 buf_printf(b, "static const struct modversion_info ____versions[]\n"); 1860 buf_printf(b, "__used\n"); 1861 buf_printf(b, "__attribute__((section(\"__versions\"))) = {\n"); 1862 1863 for (s = mod->unres; s; s = s->next) { 1864 if (!s->module) 1865 continue; 1866 if (!s->crc_valid) { 1867 warn("\"%s\" [%s.ko] has no CRC!\n", 1868 s->name, mod->name); 1869 continue; 1870 } 1871 buf_printf(b, "\t{ %#8x, \"%s\" },\n", s->crc, s->name); 1872 } 1873 1874 buf_printf(b, "};\n"); 1875 1876 return err; 1877} 1878 1879static void add_depends(struct buffer *b, struct module *mod, 1880 struct module *modules) 1881{ 1882 struct symbol *s; 1883 struct module *m; 1884 int first = 1; 1885 1886 for (m = modules; m; m = m->next) 1887 m->seen = is_vmlinux(m->name); 1888 1889 buf_printf(b, "\n"); 1890 buf_printf(b, "static const char __module_depends[]\n"); 1891 buf_printf(b, "__used\n"); 1892 buf_printf(b, "__attribute__((section(\".modinfo\"))) =\n"); 1893 buf_printf(b, "\"depends="); 1894 for (s = mod->unres; s; s = s->next) { 1895 const char *p; 1896 if (!s->module) 1897 continue; 1898 1899 if (s->module->seen) 1900 continue; 1901 1902 s->module->seen = 1; 1903 p = strrchr(s->module->name, '/'); 1904 if (p) 1905 p++; 1906 else 1907 p = s->module->name; 1908 buf_printf(b, "%s%s", first ? "" : ",", p); 1909 first = 0; 1910 } 1911 buf_printf(b, "\";\n"); 1912} 1913 1914static void add_srcversion(struct buffer *b, struct module *mod) 1915{ 1916 if (mod->srcversion[0]) { 1917 buf_printf(b, "\n"); 1918 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n", 1919 mod->srcversion); 1920 } 1921} 1922 1923static void write_if_changed(struct buffer *b, const char *fname) 1924{ 1925 char *tmp; 1926 FILE *file; 1927 struct stat st; 1928 1929 file = fopen(fname, "r"); 1930 if (!file) 1931 goto write; 1932 1933 if (fstat(fileno(file), &st) < 0) 1934 goto close_write; 1935 1936 if (st.st_size != b->pos) 1937 goto close_write; 1938 1939 tmp = NOFAIL(malloc(b->pos)); 1940 if (fread(tmp, 1, b->pos, file) != b->pos) 1941 goto free_write; 1942 1943 if (memcmp(tmp, b->p, b->pos) != 0) 1944 goto free_write; 1945 1946 free(tmp); 1947 fclose(file); 1948 return; 1949 1950 free_write: 1951 free(tmp); 1952 close_write: 1953 fclose(file); 1954 write: 1955 file = fopen(fname, "w"); 1956 if (!file) { 1957 perror(fname); 1958 exit(1); 1959 } 1960 if (fwrite(b->p, 1, b->pos, file) != b->pos) { 1961 perror(fname); 1962 exit(1); 1963 } 1964 fclose(file); 1965} 1966 1967/* parse Module.symvers file. line format: 1968 * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something] 1969 **/ 1970static void read_dump(const char *fname, unsigned int kernel) 1971{ 1972 unsigned long size, pos = 0; 1973 void *file = grab_file(fname, &size); 1974 char *line; 1975 1976 if (!file) 1977 /* No symbol versions, silently ignore */ 1978 return; 1979 1980 while ((line = get_next_line(&pos, file, size))) { 1981 char *symname, *modname, *d, *export, *end; 1982 unsigned int crc; 1983 struct module *mod; 1984 struct symbol *s; 1985 1986 if (!(symname = strchr(line, '\t'))) 1987 goto fail; 1988 *symname++ = '\0'; 1989 if (!(modname = strchr(symname, '\t'))) 1990 goto fail; 1991 *modname++ = '\0'; 1992 if ((export = strchr(modname, '\t')) != NULL) 1993 *export++ = '\0'; 1994 if (export && ((end = strchr(export, '\t')) != NULL)) 1995 *end = '\0'; 1996 crc = strtoul(line, &d, 16); 1997 if (*symname == '\0' || *modname == '\0' || *d != '\0') 1998 goto fail; 1999 mod = find_module(modname); 2000 if (!mod) { 2001 if (is_vmlinux(modname)) 2002 have_vmlinux = 1; 2003 mod = new_module(modname); 2004 mod->skip = 1; 2005 } 2006 s = sym_add_exported(symname, mod, export_no(export)); 2007 s->kernel = kernel; 2008 s->preloaded = 1; 2009 sym_update_crc(symname, mod, crc, export_no(export)); 2010 } 2011 return; 2012fail: 2013 fatal("parse error in symbol dump file\n"); 2014} 2015 2016/* For normal builds always dump all symbols. 2017 * For external modules only dump symbols 2018 * that are not read from kernel Module.symvers. 2019 **/ 2020static int dump_sym(struct symbol *sym) 2021{ 2022 if (!external_module) 2023 return 1; 2024 if (sym->vmlinux || sym->kernel) 2025 return 0; 2026 return 1; 2027} 2028 2029static void write_dump(const char *fname) 2030{ 2031 struct buffer buf = { }; 2032 struct symbol *symbol; 2033 int n; 2034 2035 for (n = 0; n < SYMBOL_HASH_SIZE ; n++) { 2036 symbol = symbolhash[n]; 2037 while (symbol) { 2038 if (dump_sym(symbol)) 2039 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\n", 2040 symbol->crc, symbol->name, 2041 symbol->module->name, 2042 export_str(symbol->export)); 2043 symbol = symbol->next; 2044 } 2045 } 2046 write_if_changed(&buf, fname); 2047} 2048 2049struct ext_sym_list { 2050 struct ext_sym_list *next; 2051 const char *file; 2052}; 2053 2054int main(int argc, char **argv) 2055{ 2056 struct module *mod; 2057 struct buffer buf = { }; 2058 char *kernel_read = NULL, *module_read = NULL; 2059 char *dump_write = NULL; 2060 int opt; 2061 int err; 2062 struct ext_sym_list *extsym_iter; 2063 struct ext_sym_list *extsym_start = NULL; 2064 2065 while ((opt = getopt(argc, argv, "i:I:e:cmsSo:awM:K:")) != -1) { 2066 switch (opt) { 2067 case 'i': 2068 kernel_read = optarg; 2069 break; 2070 case 'I': 2071 module_read = optarg; 2072 external_module = 1; 2073 break; 2074 case 'c': 2075 cross_build = 1; 2076 break; 2077 case 'e': 2078 external_module = 1; 2079 extsym_iter = 2080 NOFAIL(malloc(sizeof(*extsym_iter))); 2081 extsym_iter->next = extsym_start; 2082 extsym_iter->file = optarg; 2083 extsym_start = extsym_iter; 2084 break; 2085 case 'm': 2086 modversions = 1; 2087 break; 2088 case 'o': 2089 dump_write = optarg; 2090 break; 2091 case 'a': 2092 all_versions = 1; 2093 break; 2094 case 's': 2095 vmlinux_section_warnings = 0; 2096 break; 2097 case 'S': 2098 sec_mismatch_verbose = 0; 2099 break; 2100 case 'w': 2101 warn_unresolved = 1; 2102 break; 2103 default: 2104 exit(1); 2105 } 2106 } 2107 2108 if (kernel_read) 2109 read_dump(kernel_read, 1); 2110 if (module_read) 2111 read_dump(module_read, 0); 2112 while (extsym_start) { 2113 read_dump(extsym_start->file, 0); 2114 extsym_iter = extsym_start->next; 2115 free(extsym_start); 2116 extsym_start = extsym_iter; 2117 } 2118 2119 while (optind < argc) 2120 read_symbols(argv[optind++]); 2121 2122 for (mod = modules; mod; mod = mod->next) { 2123 if (mod->skip) 2124 continue; 2125 check_exports(mod); 2126 } 2127 2128 err = 0; 2129 2130 for (mod = modules; mod; mod = mod->next) { 2131 char fname[strlen(mod->name) + 10]; 2132 2133 if (mod->skip) 2134 continue; 2135 2136 buf.pos = 0; 2137 2138 add_header(&buf, mod); 2139 add_staging_flag(&buf, mod->name); 2140 err |= add_versions(&buf, mod); 2141 add_depends(&buf, mod, modules); 2142 add_moddevtable(&buf, mod); 2143 add_srcversion(&buf, mod); 2144 2145 sprintf(fname, "%s.mod.c", mod->name); 2146 write_if_changed(&buf, fname); 2147 } 2148 2149 if (dump_write) 2150 write_dump(dump_write); 2151 if (sec_mismatch_count && !sec_mismatch_verbose) 2152 warn("modpost: Found %d section mismatch(es).\n" 2153 "To see full details build your kernel with:\n" 2154 "'make CONFIG_DEBUG_SECTION_MISMATCH=y'\n", 2155 sec_mismatch_count); 2156 2157 return err; 2158} 2159