/* 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 <stdio.h>

#include <ctype.h>

#include <string.h>

#include <limits.h>

#include <stdbool.h>

#include <errno.h>

#include "modpost.h"

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

/* Are we using CONFIG_MODVERSIONS? */

static int modversions = 0;

/* Warn about undefined symbols? (do so if we have vmlinux) */

static int have_vmlinux = 0;

/* Is CONFIG_MODULE_SRCVERSION_ALL set? */

static int all_versions = 0;

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

static int external_module = 0;

/* Only warn about unresolved symbols */

static int warn_unresolved = 0;

/* How a symbol is exported */

static int sec_mismatch_count = 0;

static int sec_mismatch_warn_only = true;

/* ignore missing files */

static int ignore_missing_files;

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

static int allow_missing_ns_imports;

static bool error_occurred;

enum export {

export_plain, export_unused, export_gpl,

export_unused_gpl, export_gpl_future, export_unknown

};

/* 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 __attribute__((format(printf, 2, 3)))

modpost_log(enum loglevel loglevel, const char *fmt, ...)

{

va_list arglist;

switch (loglevel) {

case LOG_WARN:

fprintf(stderr, "WARNING: ");

break;

case LOG_ERROR:

fprintf(stderr, "ERROR: ");

break;

case LOG_FATAL:

fprintf(stderr, "FATAL: ");

break;

default: /* invalid loglevel, ignore */

break;

}

fprintf(stderr, "modpost: ");

va_start(arglist, fmt);

vfprintf(stderr, fmt, arglist);

va_end(arglist);

if (loglevel == LOG_FATAL)

exit(1);

if (loglevel == LOG_ERROR)

error_occurred = true;

}

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;

}

void *do_nofail(void *ptr, const char *expr)

{

if (!ptr)

fatal("Memory allocation failure: %s.\n", expr);

return ptr;

}

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 = NOFAIL(malloc(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 */

static struct module *modules;

static struct module *find_module(const char *modname)

{

struct module *mod;

for (mod = modules; mod; mod = mod->next)

if (strcmp(mod->name, modname) == 0)

break;

return mod;

}

static struct module *new_module(const char *modname)

{

struct module *mod;

mod = NOFAIL(malloc(sizeof(*mod) + strlen(modname) + 1));

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

/* add to list */

strcpy(mod->name, modname);

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

mod->gpl_compatible = -1;

mod->next = modules;

modules = mod;

if (mod->is_vmlinux)

have_vmlinux = 1;

return mod;

}

/* A hash of all exported symbols,

* struct symbol is also used for lists of unresolved symbols */

#define SYMBOL_HASH_SIZE 1024

struct symbol {

struct symbol *next;

struct module *module;

unsigned int crc;

int crc_valid;

char *namespace;

unsigned int weak:1;

unsigned int is_static:1; /* 1 if symbol is not global */

enum export export; /* Type of export */

char name[];

};

static struct symbol *symbolhash[SYMBOL_HASH_SIZE];

/* This is based on the hash agorithm from gdbm, via tdb */

static inline unsigned int tdb_hash(const char *name)

{

unsigned value; /* Used to compute the hash value. */

unsigned i; /* Used to cycle through random values. */

/* Set the initial value from the key size. */

for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)

value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));

return (1103515243 * value + 12345);

}

/**

* 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, unsigned int weak,

struct symbol *next)

{

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

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

strcpy(s->name, name);

s->weak = weak;

s->next = next;

s->is_static = 1;

return s;

}

/* For the hash of exported symbols */

static struct symbol *new_symbol(const char *name, struct module *module,

enum export export)

{

unsigned int hash;

hash = tdb_hash(name) % SYMBOL_HASH_SIZE;

symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);

return symbolhash[hash];

}

static struct symbol *find_symbol(const char *name)

{

struct symbol *s;

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

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

name++;

for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {

if (strcmp(s->name, name) == 0)

return s;

}

return NULL;

}

static bool contains_namespace(struct namespace_list *list,

const char *namespace)

{

for (; list; list = list->next)

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

return true;

return false;

}

static void add_namespace(struct namespace_list **list, const char *namespace)

{

struct namespace_list *ns_entry;

if (!contains_namespace(*list, namespace)) {

ns_entry = NOFAIL(malloc(sizeof(struct namespace_list) +

strlen(namespace) + 1));

strcpy(ns_entry->namespace, namespace);

ns_entry->next = *list;

*list = ns_entry;

}

}

static bool module_imports_namespace(struct module *module,

const char *namespace)

{

return contains_namespace(module->imported_namespaces, namespace);

}

static const struct {

const char *str;

enum export export;

} export_list[] = {

{ .str = "EXPORT_SYMBOL", .export = export_plain },

{ .str = "EXPORT_UNUSED_SYMBOL", .export = export_unused },

{ .str = "EXPORT_SYMBOL_GPL", .export = export_gpl },

{ .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },

{ .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },

{ .str = "(unknown)", .export = export_unknown },

};

static const char *export_str(enum export ex)

{

return export_list[ex].str;

}

static enum export export_no(const char *s)

{

int i;

if (!s)

return export_unknown;

for (i = 0; export_list[i].export != export_unknown; i++) {

if (strcmp(export_list[i].str, s) == 0)

return export_list[i].export;

}

return export_unknown;

}

static void *sym_get_data_by_offset(const struct elf_info *info,

unsigned int secindex, unsigned long offset)

{

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

if (info->hdr->e_type != ET_REL)

offset -= sechdr->sh_addr;

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

}

static 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, int secindex)

{

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

}

#define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0)

static enum export export_from_secname(struct elf_info *elf, unsigned int sec)

{

const char *secname = sec_name(elf, sec);

if (strstarts(secname, "___ksymtab+"))

return export_plain;

else if (strstarts(secname, "___ksymtab_unused+"))

return export_unused;

else if (strstarts(secname, "___ksymtab_gpl+"))

return export_gpl;

else if (strstarts(secname, "___ksymtab_unused_gpl+"))

return export_unused_gpl;

else if (strstarts(secname, "___ksymtab_gpl_future+"))

return export_gpl_future;

else

return export_unknown;

}

static enum export export_from_sec(struct elf_info *elf, unsigned int sec)

{

if (sec == elf->export_sec)

return export_plain;

else if (sec == elf->export_unused_sec)

return export_unused;

else if (sec == elf->export_gpl_sec)

return export_gpl;

else if (sec == elf->export_unused_gpl_sec)

return export_unused_gpl;

else if (sec == elf->export_gpl_future_sec)

return export_gpl_future;

else

return export_unknown;

}

static const char *namespace_from_kstrtabns(const struct elf_info *info,

const Elf_Sym *sym)

{

const char *value = sym_get_data(info, sym);

return value[0] ? value : NULL;

}

static void sym_update_namespace(const char *symname, const char *namespace)

{

struct symbol *s = find_symbol(symname);

/*

* That symbol should have been created earlier and thus this is

* actually an assertion.

*/

if (!s) {

error("Could not update namespace(%s) for symbol %s\n",

namespace, symname);

return;

}

free(s->namespace);

s->namespace =

namespace && namespace[0] ? NOFAIL(strdup(namespace)) : NULL;

}

/**

* Add an exported symbol - it may have already been added without a

* CRC, in this case just update the CRC

**/

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

enum export export)

{

struct symbol *s = find_symbol(name);

if (!s) {

s = new_symbol(name, mod, export);

} else if (!external_module || s->module->is_vmlinux ||

s->module == mod) {

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

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

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

return s;

}

s->module = mod;

s->export = export;

return s;

}

static void sym_set_crc(const char *name, unsigned int crc)

{

struct symbol *s = find_symbol(name);

/*

* Ignore stand-alone __crc_*, which might be auto-generated symbols

* such as __*_veneer in ARM ELF.

*/

if (!s)

return;

s->crc = crc;

s->crc_valid = 1;

}

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;

}

/* 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;

/* 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);

return 0;

}

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));

return 0;

}

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, "__ksymtab") == 0)

info->export_sec = i;

else if (strcmp(secname, "__ksymtab_unused") == 0)

info->export_unused_sec = i;

else if (strcmp(secname, "__ksymtab_gpl") == 0)

info->export_gpl_sec = i;

else if (strcmp(secname, "__ksymtab_unused_gpl") == 0)

info->export_unused_gpl_sec = i;

else if (strcmp(secname, "__ksymtab_gpl_future") == 0)

info->export_gpl_future_sec = i;

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);

}

return 1;

}

static void parse_elf_finish(struct elf_info *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_modversion(const struct module *mod,

const struct elf_info *info,

const Elf_Sym *sym, const char *symname)

{

unsigned int crc;

if (sym->st_shndx == SHN_UNDEF) {

warn("EXPORT symbol \"%s\" [%s%s] version generation failed, symbol will not be versioned.\n",

symname, mod->name, mod->is_vmlinux ? "" : ".ko");

return;

}

if (sym->st_shndx == SHN_ABS) {

crc = sym->st_value;

} else {

unsigned int *crcp;

/* symbol points to the CRC in the ELF object */

crcp = sym_get_data(info, sym);

crc = TO_NATIVE(*crcp);

}

sym_set_crc(symname, crc);

}

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

const Elf_Sym *sym, const char *symname)

{

enum export export;

const char *name;

if (strstarts(symname, "__ksymtab"))

export = export_from_secname(info, get_secindex(info, sym));

else

export = export_from_sec(info, get_secindex(info, sym));

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 = NOFAIL(strdup(symname));

munged[0] = '_';

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

symname = munged;

}

}

mod->unres = alloc_symbol(symname,

ELF_ST_BIND(sym->st_info) == STB_WEAK,

mod->unres);

break;

default:

/* All exported symbols */

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

name = symname + strlen("__ksymtab_");

sym_add_exported(name, mod, export);

}

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

mod->has_init = 1;

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

mod->has_cleanup = 1;

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);

}

/**

* Test if string s ends in string sub

* return 0 if match

**/

static int strrcmp(const char *s, const char *sub)

{

int slen, sublen;

if (!s || !sub)

return 1;

slen = strlen(s);

sublen = strlen(sub);

if ((slen == 0) || (sublen == 0))

return 1;

if (sublen > slen)

return 1;

return memcmp(s + slen - sublen, sub, sublen);

}

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

{

if (sym)

return elf->strtab + sym->st_name;

else

return "(unknown)";

}

/* The pattern is an array of simple patterns.

* "foo" will match an exact string equal to "foo"

* "*foo" will match a string that ends with "foo"

* "foo*" will match a string that begins with "foo"

* "*foo*" will match a string that contains "foo"

*/

static int match(const char *sym, const char * const pat[])

{

const char *p;

while (*pat) {

p = *pat++;

const char *endp = p + strlen(p) - 1;

/* "*foo*" */

if (*p == '*' && *endp == '*') {

char *bare = NOFAIL(strndup(p + 1, strlen(p) - 2));

char *here = strstr(sym, bare);

free(bare);

if (here != NULL)

return 1;

}

/* "*foo" */

else if (*p == '*') {

if (strrcmp(sym, p + 1) == 0)

return 1;

}

/* "foo*" */

else if (*endp == '*') {

if (strncmp(sym, p, strlen(p) - 1) == 0)

return 1;

}

/* no wildcards */

else {

if (strcmp(p, sym) == 0)

return 1;

}

}

/* no match */

return 0;

}

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

static const char *const section_white_list[] =

{

".comment*",

".debug*",

".cranges", /* sh64 */

".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.*",

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", ".meminit.rodata", \

".init.data", ".meminit.data"

#define ALL_EXIT_DATA_SECTIONS \

".exit.data", ".memexit.data"

#define ALL_INIT_TEXT_SECTIONS \

".init.text", ".meminit.text"

#define ALL_EXIT_TEXT_SECTIONS \

".exit.text", ".memexit.text"

#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_XXXINIT_SECTIONS MEM_INIT_SECTIONS

#define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS

#define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS

#define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS

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

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

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

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

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

".coldtext"

#define INIT_SECTIONS ".init.*"

#define MEM_INIT_SECTIONS ".meminit.*"

#define EXIT_SECTIONS ".exit.*"

#define MEM_EXIT_SECTIONS ".memexit.*"

#define ALL_TEXT_SECTIONS ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \

TEXT_SECTIONS, OTHER_TEXT_SECTIONS

/* init data sections */

static const char *const init_data_sections[] =

{ ALL_INIT_DATA_SECTIONS, NULL };

/* all init sections */

static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };

/* All init and exit sections (code + data) */

static const char *const init_exit_sections[] =

{ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };

/* all text sections */

static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };

/* data section */

static const char *const data_sections[] = { DATA_SECTIONS, NULL };

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

#define DEFAULT_SYMBOL_WHITE_LIST \

"*driver", \

"*_template", /* scsi uses *_template a lot */ \

"*_timer", /* arm uses ops structures named _timer a lot */ \

"*_sht", /* scsi also used *_sht to some extent */ \

"*_ops", \

"*_probe", \

"*_probe_one", \

"*_console"

static const char *const head_sections[] = { ".head.text*", NULL };

static const char *const linker_symbols[] =

{ "__init_begin", "_sinittext", "_einittext", NULL };