/* Postprocess module symbol versions

*

* Copyright 2003 Kai Germaschewski

* Copyright 2002-2004 Rusty Russell, IBM Corporation

* Copyright 2006-2008 Sam Ravnborg

* Based in part on module-init-tools/depmod.c,file2alias

*

* This software may be used and distributed according to the terms

* of the GNU General Public License, incorporated herein by reference.

*

* Usage: modpost vmlinux module1.o module2.o ...

*/

#define _GNU_SOURCE

#include <elf.h>

#include <fnmatch.h>

#include <stdio.h>

#include <ctype.h>

#include <string.h>

#include <limits.h>

#include <stdbool.h>

#include <errno.h>

#include <hash.h>

#include <hashtable.h>

#include <list.h>

#include <xalloc.h>

#include "modpost.h"

#include "../../include/linux/license.h"

static bool module_enabled;

/* Are we using CONFIG_MODVERSIONS? */

static bool modversions;

/* Is CONFIG_MODULE_SRCVERSION_ALL set? */

static bool all_versions;

/* Is CONFIG_BASIC_MODVERSIONS set? */

static bool basic_modversions;

/* Is CONFIG_EXTENDED_MODVERSIONS set? */

static bool extended_modversions;

/* If we are modposting external module set to 1 */

static bool external_module;

/* Only warn about unresolved symbols */

static bool warn_unresolved;

static int sec_mismatch_count;

static bool sec_mismatch_warn_only = true;

/* Trim EXPORT_SYMBOLs that are unused by in-tree modules */

static bool trim_unused_exports;

/* ignore missing files */

static bool ignore_missing_files;

/* If set to 1, only warn (instead of error) about missing ns imports */

static bool allow_missing_ns_imports;

static bool error_occurred;

static bool extra_warn;

bool target_is_big_endian;

bool host_is_big_endian;

/*

* Cut off the warnings when there are too many. This typically occurs when

* vmlinux is missing. ('make modules' without building vmlinux.)

*/

#define MAX_UNRESOLVED_REPORTS 10

static unsigned int nr_unresolved;

/* In kernel, this size is defined in linux/module.h;

* here we use Elf_Addr instead of long for covering cross-compile

*/

#define MODULE_NAME_LEN (64 - sizeof(Elf_Addr))

void modpost_log(bool is_error, const char *fmt, ...)

{

va_list arglist;

if (is_error) {

fprintf(stderr, "ERROR: ");

error_occurred = true;

} else {

fprintf(stderr, "WARNING: ");

}

fprintf(stderr, "modpost: ");

va_start(arglist, fmt);

vfprintf(stderr, fmt, arglist);

va_end(arglist);

}

static inline bool strends(const char *str, const char *postfix)

{

if (strlen(str) < strlen(postfix))

return false;

return strcmp(str + strlen(str) - strlen(postfix), postfix) == 0;

}

char *read_text_file(const char *filename)

{

struct stat st;

size_t nbytes;

int fd;

char *buf;

fd = open(filename, O_RDONLY);

if (fd < 0) {

perror(filename);

exit(1);

}

if (fstat(fd, &st) < 0) {

perror(filename);

exit(1);

}

buf = xmalloc(st.st_size + 1);

nbytes = st.st_size;

while (nbytes) {

ssize_t bytes_read;

bytes_read = read(fd, buf, nbytes);

if (bytes_read < 0) {

perror(filename);

exit(1);

}

nbytes -= bytes_read;

}

buf[st.st_size] = '\0';

close(fd);

return buf;

}

char *get_line(char **stringp)

{

char *orig = *stringp, *next;

/* do not return the unwanted extra line at EOF */

if (!orig || *orig == '\0')

return NULL;

/* don't use strsep here, it is not available everywhere */

next = strchr(orig, '\n');

if (next)

*next++ = '\0';

*stringp = next;

return orig;

}

/* A list of all modules we processed */

LIST_HEAD(modules);

static struct module *find_module(const char *filename, const char *modname)

{

struct module *mod;

list_for_each_entry(mod, &modules, list) {

if (!strcmp(mod->dump_file, filename) &&

!strcmp(mod->name, modname))

return mod;

}

return NULL;

}

static struct module *new_module(const char *name, size_t namelen)

{

struct module *mod;

mod = xmalloc(sizeof(*mod) + namelen + 1);

memset(mod, 0, sizeof(*mod));

INIT_LIST_HEAD(&mod->exported_symbols);

INIT_LIST_HEAD(&mod->unresolved_symbols);

INIT_LIST_HEAD(&mod->missing_namespaces);

INIT_LIST_HEAD(&mod->imported_namespaces);

INIT_LIST_HEAD(&mod->aliases);

memcpy(mod->name, name, namelen);

mod->name[namelen] = '\0';

mod->is_vmlinux = (strcmp(mod->name, "vmlinux") == 0);

/*

* Set mod->is_gpl_compatible to true by default. If MODULE_LICENSE()

* is missing, do not check the use for EXPORT_SYMBOL_GPL() because

* modpost will exit with an error anyway.

*/

mod->is_gpl_compatible = true;

list_add_tail(&mod->list, &modules);

return mod;

}

struct symbol {

struct hlist_node hnode;/* link to hash table */

struct list_head list; /* link to module::exported_symbols or module::unresolved_symbols */

struct module *module;

char *namespace;

unsigned int crc;

bool crc_valid;

bool weak;

bool is_func;

bool is_gpl_only; /* exported by EXPORT_SYMBOL_GPL */

bool used; /* there exists a user of this symbol */

char name[];

};

static HASHTABLE_DEFINE(symbol_hashtable, 1U << 10);

/**

* Allocate a new symbols for use in the hash of exported symbols or

* the list of unresolved symbols per module

**/

static struct symbol *alloc_symbol(const char *name)

{

struct symbol *s = xmalloc(sizeof(*s) + strlen(name) + 1);

memset(s, 0, sizeof(*s));

strcpy(s->name, name);

return s;

}

/* For the hash of exported symbols */

static void hash_add_symbol(struct symbol *sym)

{

hash_add(symbol_hashtable, &sym->hnode, hash_str(sym->name));

}

static void sym_add_unresolved(const char *name, struct module *mod, bool weak)

{

struct symbol *sym;

sym = alloc_symbol(name);

sym->weak = weak;

list_add_tail(&sym->list, &mod->unresolved_symbols);

}

static struct symbol *sym_find_with_module(const char *name, struct module *mod)

{

struct symbol *s;

/* For our purposes, .foo matches foo. PPC64 needs this. */

if (name[0] == '.')

name++;

hash_for_each_possible(symbol_hashtable, s, hnode, hash_str(name)) {

if (strcmp(s->name, name) == 0 && (!mod || s->module == mod))

return s;

}

return NULL;

}

static struct symbol *find_symbol(const char *name)

{

return sym_find_with_module(name, NULL);

}

struct namespace_list {

struct list_head list;

char namespace[];

};

static bool contains_namespace(struct list_head *head, const char *namespace)

{

struct namespace_list *list;

/*

* The default namespace is null string "", which is always implicitly

* contained.

*/

if (!namespace[0])

return true;

list_for_each_entry(list, head, list) {

if (!strcmp(list->namespace, namespace))

return true;

}

return false;

}

static void add_namespace(struct list_head *head, const char *namespace)

{

struct namespace_list *ns_entry;

if (!contains_namespace(head, namespace)) {

ns_entry = xmalloc(sizeof(*ns_entry) + strlen(namespace) + 1);

strcpy(ns_entry->namespace, namespace);

list_add_tail(&ns_entry->list, head);

}

}

static void *sym_get_data_by_offset(const struct elf_info *info,

unsigned int secindex, unsigned long offset)

{

Elf_Shdr *sechdr = &info->sechdrs[secindex];

return (void *)info->hdr + sechdr->sh_offset + offset;

}

void *sym_get_data(const struct elf_info *info, const Elf_Sym *sym)

{

return sym_get_data_by_offset(info, get_secindex(info, sym),

sym->st_value);

}

static const char *sech_name(const struct elf_info *info, Elf_Shdr *sechdr)

{

return sym_get_data_by_offset(info, info->secindex_strings,

sechdr->sh_name);

}

static const char *sec_name(const struct elf_info *info, unsigned int secindex)

{

/*

* If sym->st_shndx is a special section index, there is no

* corresponding section header.

* Return "" if the index is out of range of info->sechdrs[] array.

*/

if (secindex >= info->num_sections)

return "";

return sech_name(info, &info->sechdrs[secindex]);

}

static struct symbol *sym_add_exported(const char *name, struct module *mod,

bool gpl_only, const char *namespace)

{

struct symbol *s = find_symbol(name);

if (s && (!external_module || s->module->is_vmlinux || s->module == mod)) {

error("%s: '%s' exported twice. Previous export was in %s%s\n",

mod->name, name, s->module->name,

s->module->is_vmlinux ? "" : ".ko");

}

s = alloc_symbol(name);

s->module = mod;

s->is_gpl_only = gpl_only;

s->namespace = xstrdup(namespace);

list_add_tail(&s->list, &mod->exported_symbols);

hash_add_symbol(s);

return s;

}

static void sym_set_crc(struct symbol *sym, unsigned int crc)

{

sym->crc = crc;

sym->crc_valid = true;

}

static void *grab_file(const char *filename, size_t *size)

{

struct stat st;

void *map = MAP_FAILED;

int fd;

fd = open(filename, O_RDONLY);

if (fd < 0)

return NULL;

if (fstat(fd, &st))

goto failed;

*size = st.st_size;

map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);

failed:

close(fd);

if (map == MAP_FAILED)

return NULL;

return map;

}

static void release_file(void *file, size_t size)

{

munmap(file, size);

}

static int parse_elf(struct elf_info *info, const char *filename)

{

unsigned int i;

Elf_Ehdr *hdr;

Elf_Shdr *sechdrs;

Elf_Sym *sym;

const char *secstrings;

unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;

hdr = grab_file(filename, &info->size);

if (!hdr) {

if (ignore_missing_files) {

fprintf(stderr, "%s: %s (ignored)\n", filename,

strerror(errno));

return 0;

}

perror(filename);

exit(1);

}

info->hdr = hdr;

if (info->size < sizeof(*hdr)) {

/* file too small, assume this is an empty .o file */

return 0;

}

/* Is this a valid ELF file? */

if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||

(hdr->e_ident[EI_MAG1] != ELFMAG1) ||

(hdr->e_ident[EI_MAG2] != ELFMAG2) ||

(hdr->e_ident[EI_MAG3] != ELFMAG3)) {

/* Not an ELF file - silently ignore it */

return 0;

}

switch (hdr->e_ident[EI_DATA]) {

case ELFDATA2LSB:

target_is_big_endian = false;

break;

case ELFDATA2MSB:

target_is_big_endian = true;

break;

default:

fatal("target endian is unknown\n");

}

/* Fix endianness in ELF header */

hdr->e_type = TO_NATIVE(hdr->e_type);

hdr->e_machine = TO_NATIVE(hdr->e_machine);

hdr->e_version = TO_NATIVE(hdr->e_version);

hdr->e_entry = TO_NATIVE(hdr->e_entry);

hdr->e_phoff = TO_NATIVE(hdr->e_phoff);

hdr->e_shoff = TO_NATIVE(hdr->e_shoff);

hdr->e_flags = TO_NATIVE(hdr->e_flags);

hdr->e_ehsize = TO_NATIVE(hdr->e_ehsize);

hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);

hdr->e_phnum = TO_NATIVE(hdr->e_phnum);

hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);

hdr->e_shnum = TO_NATIVE(hdr->e_shnum);

hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);

sechdrs = (void *)hdr + hdr->e_shoff;

info->sechdrs = sechdrs;

/* modpost only works for relocatable objects */

if (hdr->e_type != ET_REL)

fatal("%s: not relocatable object.", filename);

/* Check if file offset is correct */

if (hdr->e_shoff > info->size)

fatal("section header offset=%lu in file '%s' is bigger than filesize=%zu\n",

(unsigned long)hdr->e_shoff, filename, info->size);

if (hdr->e_shnum == SHN_UNDEF) {

/*

* There are more than 64k sections,

* read count from .sh_size.

*/

info->num_sections = TO_NATIVE(sechdrs[0].sh_size);

}

else {

info->num_sections = hdr->e_shnum;

}

if (hdr->e_shstrndx == SHN_XINDEX) {

info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link);

}

else {

info->secindex_strings = hdr->e_shstrndx;

}

/* Fix endianness in section headers */

for (i = 0; i < info->num_sections; i++) {

sechdrs[i].sh_name = TO_NATIVE(sechdrs[i].sh_name);

sechdrs[i].sh_type = TO_NATIVE(sechdrs[i].sh_type);

sechdrs[i].sh_flags = TO_NATIVE(sechdrs[i].sh_flags);

sechdrs[i].sh_addr = TO_NATIVE(sechdrs[i].sh_addr);

sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);

sechdrs[i].sh_size = TO_NATIVE(sechdrs[i].sh_size);

sechdrs[i].sh_link = TO_NATIVE(sechdrs[i].sh_link);

sechdrs[i].sh_info = TO_NATIVE(sechdrs[i].sh_info);

sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);

sechdrs[i].sh_entsize = TO_NATIVE(sechdrs[i].sh_entsize);

}

/* Find symbol table. */

secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;

for (i = 1; i < info->num_sections; i++) {

const char *secname;

int nobits = sechdrs[i].sh_type == SHT_NOBITS;

if (!nobits && sechdrs[i].sh_offset > info->size)

fatal("%s is truncated. sechdrs[i].sh_offset=%lu > sizeof(*hrd)=%zu\n",

filename, (unsigned long)sechdrs[i].sh_offset,

sizeof(*hdr));

secname = secstrings + sechdrs[i].sh_name;

if (strcmp(secname, ".modinfo") == 0) {

if (nobits)

fatal("%s has NOBITS .modinfo\n", filename);

info->modinfo = (void *)hdr + sechdrs[i].sh_offset;

info->modinfo_len = sechdrs[i].sh_size;

} else if (!strcmp(secname, ".export_symbol")) {

info->export_symbol_secndx = i;

} else if (!strcmp(secname, ".no_trim_symbol")) {

info->no_trim_symbol = (void *)hdr + sechdrs[i].sh_offset;

info->no_trim_symbol_len = sechdrs[i].sh_size;

}

if (sechdrs[i].sh_type == SHT_SYMTAB) {

unsigned int sh_link_idx;

symtab_idx = i;

info->symtab_start = (void *)hdr +

sechdrs[i].sh_offset;

info->symtab_stop = (void *)hdr +

sechdrs[i].sh_offset + sechdrs[i].sh_size;

sh_link_idx = sechdrs[i].sh_link;

info->strtab = (void *)hdr +

sechdrs[sh_link_idx].sh_offset;

}

/* 32bit section no. table? ("more than 64k sections") */

if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {

symtab_shndx_idx = i;

info->symtab_shndx_start = (void *)hdr +

sechdrs[i].sh_offset;

info->symtab_shndx_stop = (void *)hdr +

sechdrs[i].sh_offset + sechdrs[i].sh_size;

}

}

if (!info->symtab_start)

fatal("%s has no symtab?\n", filename);

/* Fix endianness in symbols */

for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {

sym->st_shndx = TO_NATIVE(sym->st_shndx);

sym->st_name = TO_NATIVE(sym->st_name);

sym->st_value = TO_NATIVE(sym->st_value);

sym->st_size = TO_NATIVE(sym->st_size);

}

if (symtab_shndx_idx != ~0U) {

Elf32_Word *p;

if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)

fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",

filename, sechdrs[symtab_shndx_idx].sh_link,

symtab_idx);

/* Fix endianness */

for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;

p++)

*p = TO_NATIVE(*p);

}

symsearch_init(info);

return 1;

}

static void parse_elf_finish(struct elf_info *info)

{

symsearch_finish(info);

release_file(info->hdr, info->size);

}

static int ignore_undef_symbol(struct elf_info *info, const char *symname)

{

/* ignore __this_module, it will be resolved shortly */

if (strcmp(symname, "__this_module") == 0)

return 1;

/* ignore global offset table */

if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)

return 1;

if (info->hdr->e_machine == EM_PPC)

/* Special register function linked on all modules during final link of .ko */

if (strstarts(symname, "_restgpr_") ||

strstarts(symname, "_savegpr_") ||

strstarts(symname, "_rest32gpr_") ||

strstarts(symname, "_save32gpr_") ||

strstarts(symname, "_restvr_") ||

strstarts(symname, "_savevr_"))

return 1;

if (info->hdr->e_machine == EM_PPC64)

/* Special register function linked on all modules during final link of .ko */

if (strstarts(symname, "_restgpr0_") ||

strstarts(symname, "_savegpr0_") ||

strstarts(symname, "_restvr_") ||

strstarts(symname, "_savevr_") ||

strcmp(symname, ".TOC.") == 0)

return 1;

/* Do not ignore this symbol */

return 0;

}

static void handle_symbol(struct module *mod, struct elf_info *info,

const Elf_Sym *sym, const char *symname)

{

switch (sym->st_shndx) {

case SHN_COMMON:

if (strstarts(symname, "__gnu_lto_")) {

/* Should warn here, but modpost runs before the linker */

} else

warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);

break;

case SHN_UNDEF:

/* undefined symbol */

if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&

ELF_ST_BIND(sym->st_info) != STB_WEAK)

break;

if (ignore_undef_symbol(info, symname))

break;

if (info->hdr->e_machine == EM_SPARC ||

info->hdr->e_machine == EM_SPARCV9) {

/* Ignore register directives. */

if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)

break;

if (symname[0] == '.') {

char *munged = xstrdup(symname);

munged[0] = '_';

munged[1] = toupper(munged[1]);

symname = munged;

}

}

sym_add_unresolved(symname, mod,

ELF_ST_BIND(sym->st_info) == STB_WEAK);

break;

default:

if (strcmp(symname, "init_module") == 0)

mod->has_init = true;

if (strcmp(symname, "cleanup_module") == 0)

mod->has_cleanup = true;

break;

}

}

/**

* Parse tag=value strings from .modinfo section

**/

static char *next_string(char *string, unsigned long *secsize)

{

/* Skip non-zero chars */

while (string[0]) {

string++;

if ((*secsize)-- <= 1)

return NULL;

}

/* Skip any zero padding. */

while (!string[0]) {

string++;

if ((*secsize)-- <= 1)

return NULL;

}

return string;

}

static char *get_next_modinfo(struct elf_info *info, const char *tag,

char *prev)

{

char *p;

unsigned int taglen = strlen(tag);

char *modinfo = info->modinfo;

unsigned long size = info->modinfo_len;

if (prev) {

size -= prev - modinfo;

modinfo = next_string(prev, &size);

}

for (p = modinfo; p; p = next_string(p, &size)) {

if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')

return p + taglen + 1;

}

return NULL;

}

static char *get_modinfo(struct elf_info *info, const char *tag)

{

return get_next_modinfo(info, tag, NULL);

}

static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)

{

return sym ? elf->strtab + sym->st_name : "";

}

/*

* Check whether the 'string' argument matches one of the 'patterns',

* an array of shell wildcard patterns (glob).

*

* Return true is there is a match.

*/

static bool match(const char *string, const char *const patterns[])

{

const char *pattern;

while ((pattern = *patterns++)) {

if (!fnmatch(pattern, string, 0))

return true;

}

return false;

}

/* useful to pass patterns to match() directly */

#define PATTERNS(...) \

({ \

static const char *const patterns[] = {__VA_ARGS__, NULL}; \

patterns; \

})

/* sections that we do not want to do full section mismatch check on */

static const char *const section_white_list[] =

{

".comment*",

".debug*",

".zdebug*", /* Compressed debug sections. */

".GCC.command.line", /* record-gcc-switches */

".mdebug*", /* alpha, score, mips etc. */

".pdr", /* alpha, score, mips etc. */

".stab*",

".note*",

".got*",

".toc*",

".xt.prop", /* xtensa */

".xt.lit", /* xtensa */

".arcextmap*", /* arc */

".gnu.linkonce.arcext*", /* arc : modules */

".cmem*", /* EZchip */

".fmt_slot*", /* EZchip */

".gnu.lto*",

".discard.*",

".llvm.call-graph-profile", /* call graph */

NULL

};

/*

* This is used to find sections missing the SHF_ALLOC flag.

* The cause of this is often a section specified in assembler

* without "ax" / "aw".

*/

static void check_section(const char *modname, struct elf_info *elf,

Elf_Shdr *sechdr)

{

const char *sec = sech_name(elf, sechdr);

if (sechdr->sh_type == SHT_PROGBITS &&

!(sechdr->sh_flags & SHF_ALLOC) &&

!match(sec, section_white_list)) {

warn("%s (%s): unexpected non-allocatable section.\n"

"Did you forget to use \"ax\"/\"aw\" in a .S file?\n"

"Note that for example <linux/init.h> contains\n"

"section definitions for use in .S files.\n\n",

modname, sec);

}

}

#define ALL_INIT_DATA_SECTIONS \

".init.setup", ".init.rodata", ".init.data"

#define ALL_PCI_INIT_SECTIONS \

".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \

".pci_fixup_enable", ".pci_fixup_resume", \

".pci_fixup_resume_early", ".pci_fixup_suspend"

#define ALL_INIT_SECTIONS ".init.*"

#define ALL_EXIT_SECTIONS ".exit.*"

#define DATA_SECTIONS ".data", ".data.rel"

#define TEXT_SECTIONS ".text", ".text.*", ".sched.text", \

".kprobes.text", ".cpuidle.text", ".noinstr.text", \

".ltext", ".ltext.*"

#define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \

".fixup", ".entry.text", ".exception.text", \

".coldtext", ".softirqentry.text", ".irqentry.text"

#define ALL_TEXT_SECTIONS ".init.text", ".exit.text", \

TEXT_SECTIONS, OTHER_TEXT_SECTIONS

enum mismatch {

TEXTDATA_TO_ANY_INIT_EXIT,

XXXINIT_TO_SOME_INIT,

ANY_INIT_TO_ANY_EXIT,

ANY_EXIT_TO_ANY_INIT,

EXTABLE_TO_NON_TEXT,

};

/**

* Describe how to match sections on different criteria:

*

* @fromsec: Array of sections to be matched.

*

* @bad_tosec: Relocations applied to a section in @fromsec to a section in

* this array is forbidden (black-list). Can be empty.

*

* @good_tosec: Relocations applied to a section in @fromsec must be

* targeting sections in this array (white-list). Can be empty.

*

* @mismatch: Type of mismatch.

*/

struct sectioncheck {

const char *fromsec[20];

const char *bad_tosec[20];

const char *good_tosec[20];

enum mismatch mismatch;

};

static const struct sectioncheck sectioncheck[] = {

/* Do not reference init/exit code/data from

* normal code and data

*/

{

.fromsec = { TEXT_SECTIONS, DATA_SECTIONS, NULL },

.bad_tosec = { ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL },

.mismatch = TEXTDATA_TO_ANY_INIT_EXIT,

},

/* Do not use exit code/data from init code */

{

.fromsec = { ALL_INIT_SECTIONS, NULL },

.bad_tosec = { ALL_EXIT_SECTIONS, NULL },

.mismatch = ANY_INIT_TO_ANY_EXIT,

},

/* Do not use init code/data from exit code */

{

.fromsec = { ALL_EXIT_SECTIONS, NULL },

.bad_tosec = { ALL_INIT_SECTIONS, NULL },

.mismatch = ANY_EXIT_TO_ANY_INIT,

},

{

.fromsec = { ALL_PCI_INIT_SECTIONS, NULL },

.bad_tosec = { ALL_INIT_SECTIONS, NULL },

.mismatch = ANY_INIT_TO_ANY_EXIT,

},

{

.fromsec = { "__ex_table", NULL },

/* If you're adding any new black-listed sections in here, consider

* adding a special 'printer' for them in scripts/check_extable.

*/

.bad_tosec = { ".altinstr_replacement", NULL },

.good_tosec = {ALL_TEXT_SECTIONS , NULL},

.mismatch = EXTABLE_TO_NON_TEXT,

}

};

static const struct sectioncheck *section_mismatch(

const char *fromsec, const char *tosec)

{

int i;

/*

* The target section could be the SHT_NUL section when we're

* handling relocations to un-resolved symbols, trying to match it

* doesn't make much sense and causes build failures on parisc

* architectures.

*/

if (*tosec == '\0')

return NULL;

for (i = 0; i < ARRAY_SIZE(sectioncheck); i++) {

const struct sectioncheck *check = &sectioncheck[i];

if (match(fromsec, check->fromsec)) {

if (check->bad_tosec[0] && match(tosec, check->bad_tosec))

return check;

if (check->good_tosec[0] && !match(tosec, check->good_tosec))

return check;

}

}

return NULL;

}

/**

* Whitelist to allow certain references to pass with no warning.

*

* Pattern 1:

* If a module parameter is declared __initdata and permissions=0

* then this is legal despite the warning generated.

* We cannot see value of permissions here, so just ignore

* this pattern.

* The pattern is identified by:

* tosec = .init.data

* fromsec = .data*

* atsym =__param*

*

* Pattern 1a:

* module_param_call() ops can refer to __init set function if permissions=0

* The pattern is identified by:

* tosec = .init.text

* fromsec = .data*

* atsym = __param_ops_*

*

* Pattern 3:

* Whitelist all references from .head.text to any init section

*

* Pattern 4:

* Some symbols belong to init section but still it is ok to reference

* these from non-init sections as these symbols don't have any memory

* allocated for them and symbol address and value are same. So even

* if init section is freed, its ok to reference those symbols.

* For ex. symbols marking the init section boundaries.

* This pattern is identified by

* refsymname = __init_begin, _sinittext, _einittext

*

* Pattern 5:

* GCC may optimize static inlines when fed constant arg(s) resulting

* in functions like cpumask_empty() -- generating an associated symbol

* cpumask_empty.constprop.3 that appears in the audit. If the const that

* is passed in comes from __init, like say nmi_ipi_mask, we get a

* meaningless section warning. May need to add isra symbols too...

* This pattern is identified by

* tosec = init section

* fromsec = text section

* refsymname = *.constprop.*

*

**/

static int secref_whitelist(const char *fromsec, const char *fromsym,

const char *tosec, const char *tosym)

{

/* Check for pattern 1 */

if (match(tosec, PATTERNS(ALL_INIT_DATA_SECTIONS)) &&

match(fromsec, PATTERNS(DATA_SECTIONS)) &&

strstarts(fromsym, "__param"))

return 0;

/* Check for pattern 1a */

if (strcmp(tosec, ".init.text") == 0 &&

match(fromsec, PATTERNS(DATA_SECTIONS)) &&

strstarts(fromsym, "__param_ops_"))

return 0;

/* symbols in data sections that may refer to any init/exit sections */

if (match(fromsec, PATTERNS(DATA_SECTIONS)) &&

match(tosec, PATTERNS(ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS)) &&

match(fromsym, PATTERNS("*_ops", "*_probe", "*_console")))

return 0;

/* Check for pattern 3 */

if (strstarts(fromsec, ".head.text") &&

match(tosec, PATTERNS(ALL_INIT_SECTIONS)))

return 0;

/* Check for pattern 4 */

if (match(tosym, PATTERNS("__init_begin", "_sinittext", "_einittext")))

return 0;

/* Check for pattern 5 */

if (match(fromsec, PATTERNS(ALL_TEXT_SECTIONS)) &&

match(tosec, PATTERNS(ALL_INIT_SECTIONS)) &&

match(fromsym, PATTERNS("*.constprop.*")))

return 0;

return 1;

}

static Elf_Sym *find_fromsym(struct elf_info *elf, Elf_Addr addr,

unsigned int secndx)

{

return symsearch_find_nearest(elf, addr, secndx, false, ~0);

}

static Elf_Sym *find_tosym(struct elf_info *elf, Elf_Addr addr, Elf_Sym *sym)

{

Elf_Sym *new_sym;

/* If the supplied symbol has a valid name, return it */

if (is_valid_name(elf, sym))

return sym;

/*

* Strive to find a better symbol name, but the resulting name may not

* match the symbol referenced in the original code.

*/

new_sym = symsearch_find_nearest(elf, addr, get_secindex(elf, sym),

true, 20);

return new_sym ? new_sym : sym;

}

static bool is_executable_section(struct elf_info *elf, unsigned int secndx)

{

if (secndx >= elf->num_sections)

return false;

return (elf->sechdrs[secndx].sh_flags & SHF_EXECINSTR) != 0;

}

static void default_mismatch_handler(const char *modname, struct elf_info *elf,

const struct sectioncheck* const mismatch,

Elf_Sym *tsym,

unsigned int fsecndx, const char *fromsec, Elf_Addr faddr,

const char *tosec, Elf_Addr taddr)

{

Elf_Sym *from;