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