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