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