adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-28 03:36:19 +00:00
Code Issues Projects Releases Packages Wiki Activity

module: generic each_symbol iterator function

Browse source 
Introduce an each_symbol() iterator to avoid duplicating the knowledge
about the 5 different sections containing symbols.  Currently only
used by find_symbol(), but will be used by symbol_put_addr() too.

(Includes NULL ptr deref fix by Jiri Kosina <jkosina@suse.cz>)

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
Cc: Jiri Kosina <jkosina@suse.cz>
This commit is contained in:
Rusty Russell 2008-07-22 19:24:25 -05:00
parent da39ba5e1d
commit dafd0940c9
1 changed files with 139 additions and 115 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

254
kernel/module.c
View file

@ -152,28 +152,127 @@ extern const unsigned long __start___kcrctab_unused_gpl[];
#define symversion(base, idx) ((base != NULL) ? ((base) + (idx)) : NULL) #define symversion(base, idx) ((base != NULL) ? ((base) + (idx)) : NULL)
#endif #endif
/* lookup symbol in given range of kernel_symbols */ struct symsearch {
static const struct kernel_symbol *lookup_symbol(const char *name, const struct kernel_symbol *start, *stop;
const struct kernel_symbol *start, const unsigned long *crcs;
const struct kernel_symbol *stop) enum {
NOT_GPL_ONLY,
GPL_ONLY,
WILL_BE_GPL_ONLY,
} licence;
bool unused;
};
static bool each_symbol_in_section(const struct symsearch *arr,
unsigned int arrsize,
struct module *owner,
bool (*fn)(const struct symsearch *syms,
struct module *owner,
unsigned int symnum, void *data),
void *data)
{ {
const struct kernel_symbol *ks = start; unsigned int i, j;
for (; ks < stop; ks++)
if (strcmp(ks->name, name) == 0) for (j = 0; j < arrsize; j++) {
return ks; for (i = 0; i < arr[j].stop - arr[j].start; i++)
return NULL; if (fn(&arr[j], owner, i, data))
return true;
}
return false;
} }
static bool always_ok(bool gplok, bool warn, const char *name) /* Returns true as soon as fn returns true, otherwise false. */
static bool each_symbol(bool (*fn)(const struct symsearch *arr,
struct module *owner,
unsigned int symnum, void *data),
void *data)
{ {
return true; struct module *mod;
const struct symsearch arr[] = {
{ __start___ksymtab, __stop___ksymtab, __start___kcrctab,
NOT_GPL_ONLY, false },
{ __start___ksymtab_gpl, __stop___ksymtab_gpl,
__start___kcrctab_gpl,
GPL_ONLY, false },
{ __start___ksymtab_gpl_future, __stop___ksymtab_gpl_future,
__start___kcrctab_gpl_future,
WILL_BE_GPL_ONLY, false },
{ __start___ksymtab_unused, __stop___ksymtab_unused,
__start___kcrctab_unused,
NOT_GPL_ONLY, true },
{ __start___ksymtab_unused_gpl, __stop___ksymtab_unused_gpl,
__start___kcrctab_unused_gpl,
GPL_ONLY, true },
};
if (each_symbol_in_section(arr, ARRAY_SIZE(arr), NULL, fn, data))
return true;
list_for_each_entry(mod, &modules, list) {
struct symsearch arr[] = {
{ mod->syms, mod->syms + mod->num_syms, mod->crcs,
NOT_GPL_ONLY, false },
{ mod->gpl_syms, mod->gpl_syms + mod->num_gpl_syms,
mod->gpl_crcs,
GPL_ONLY, false },
{ mod->gpl_future_syms,
mod->gpl_future_syms + mod->num_gpl_future_syms,
mod->gpl_future_crcs,
WILL_BE_GPL_ONLY, false },
{ mod->unused_syms,
mod->unused_syms + mod->num_unused_syms,
mod->unused_crcs,
NOT_GPL_ONLY, true },
{ mod->unused_gpl_syms,
mod->unused_gpl_syms + mod->num_unused_gpl_syms,
mod->unused_gpl_crcs,
GPL_ONLY, true },
};
if (each_symbol_in_section(arr, ARRAY_SIZE(arr), mod, fn, data))
return true;
}
return false;
} }
static bool printk_unused_warning(bool gplok, bool warn, const char *name) struct find_symbol_arg {
/* Input */
const char *name;
bool gplok;
bool warn;
/* Output */
struct module *owner;
const unsigned long *crc;
unsigned long value;
};
static bool find_symbol_in_section(const struct symsearch *syms,
struct module *owner,
unsigned int symnum, void *data)
{ {
if (warn) { struct find_symbol_arg *fsa = data;
if (strcmp(syms->start[symnum].name, fsa->name) != 0)
return false;
if (!fsa->gplok) {
if (syms->licence == GPL_ONLY)
return false;
if (syms->licence == WILL_BE_GPL_ONLY && fsa->warn) {
printk(KERN_WARNING "Symbol %s is being used "
"by a non-GPL module, which will not "
"be allowed in the future\n", fsa->name);
printk(KERN_WARNING "Please see the file "
"Documentation/feature-removal-schedule.txt "
"in the kernel source tree for more details.\n");
}
}
if (syms->unused && fsa->warn) {
printk(KERN_WARNING "Symbol %s is marked as UNUSED, " printk(KERN_WARNING "Symbol %s is marked as UNUSED, "
"however this module is using it.\n", name); "however this module is using it.\n", fsa->name);
printk(KERN_WARNING printk(KERN_WARNING
"This symbol will go away in the future.\n"); "This symbol will go away in the future.\n");
printk(KERN_WARNING printk(KERN_WARNING
@ -182,64 +281,13 @@ static bool printk_unused_warning(bool gplok, bool warn, const char *name)
"mailinglist together with submitting your code for " "mailinglist together with submitting your code for "
"inclusion.\n"); "inclusion.\n");
} }
fsa->owner = owner;
fsa->crc = symversion(syms->crcs, symnum);
fsa->value = syms->start[symnum].value;
return true; return true;
} }
static bool gpl_only_unused_warning(bool gplok, bool warn, const char *name)
{
if (!gplok)
return false;
return printk_unused_warning(gplok, warn, name);
}
static bool gpl_only(bool gplok, bool warn, const char *name)
{
return gplok;
}
static bool warn_if_not_gpl(bool gplok, bool warn, const char *name)
{
if (!gplok && warn) {
printk(KERN_WARNING "Symbol %s is being used "
"by a non-GPL module, which will not "
"be allowed in the future\n", name);
printk(KERN_WARNING "Please see the file "
"Documentation/feature-removal-schedule.txt "
"in the kernel source tree for more details.\n");
}
return true;
}
struct symsearch {
const struct kernel_symbol *start, *stop;
const unsigned long *crcs;
bool (*check)(bool gplok, bool warn, const char *name);
};
/* Look through this array of symbol tables for a symbol match which
* passes the check function. */
static const struct kernel_symbol *search_symarrays(const struct symsearch *arr,
unsigned int num,
const char *name,
bool gplok,
bool warn,
const unsigned long **crc)
{
unsigned int i;
const struct kernel_symbol *ks;
for (i = 0; i < num; i++) {
ks = lookup_symbol(name, arr[i].start, arr[i].stop);
if (!ks || !arr[i].check(gplok, warn, name))
continue;
if (crc)
*crc = symversion(arr[i].crcs, ks - arr[i].start);
return ks;
}
return NULL;
}
/* Find a symbol, return value, (optional) crc and (optional) module /* Find a symbol, return value, (optional) crc and (optional) module
* which owns it */ * which owns it */
static unsigned long find_symbol(const char *name, static unsigned long find_symbol(const char *name,
@ -248,60 +296,36 @@ static unsigned long find_symbol(const char *name,
bool gplok, bool gplok,
bool warn) bool warn)
{ {
struct module *mod; struct find_symbol_arg fsa;
const struct kernel_symbol *ks;
const struct symsearch arr[] = {
{ __start___ksymtab, __stop___ksymtab, __start___kcrctab,
always_ok },
{ __start___ksymtab_gpl, __stop___ksymtab_gpl,
__start___kcrctab_gpl, gpl_only },
{ __start___ksymtab_gpl_future, __stop___ksymtab_gpl_future,
__start___kcrctab_gpl_future, warn_if_not_gpl },
{ __start___ksymtab_unused, __stop___ksymtab_unused,
__start___kcrctab_unused, printk_unused_warning },
{ __start___ksymtab_unused_gpl, __stop___ksymtab_unused_gpl,
__start___kcrctab_unused_gpl, gpl_only_unused_warning },
};
/* Core kernel first. */ fsa.name = name;
ks = search_symarrays(arr, ARRAY_SIZE(arr), name, gplok, warn, crc); fsa.gplok = gplok;
if (ks) { fsa.warn = warn;
if (each_symbol(find_symbol_in_section, &fsa)) {
if (owner) if (owner)
*owner = NULL; *owner = fsa.owner;
return ks->value; if (crc)
} *crc = fsa.crc;
return fsa.value;
/* Now try modules. */
list_for_each_entry(mod, &modules, list) {
struct symsearch arr[] = {
{ mod->syms, mod->syms + mod->num_syms, mod->crcs,
always_ok },
{ mod->gpl_syms, mod->gpl_syms + mod->num_gpl_syms,
mod->gpl_crcs, gpl_only },
{ mod->gpl_future_syms,
mod->gpl_future_syms + mod->num_gpl_future_syms,
mod->gpl_future_crcs, warn_if_not_gpl },
{ mod->unused_syms,
mod->unused_syms + mod->num_unused_syms,
mod->unused_crcs, printk_unused_warning },
{ mod->unused_gpl_syms,
mod->unused_gpl_syms + mod->num_unused_gpl_syms,
mod->unused_gpl_crcs, gpl_only_unused_warning },
};
ks = search_symarrays(arr, ARRAY_SIZE(arr),
name, gplok, warn, crc);
if (ks) {
if (owner)
*owner = mod;
return ks->value;
}
} }
DEBUGP("Failed to find symbol %s\n", name); DEBUGP("Failed to find symbol %s\n", name);
return -ENOENT; return -ENOENT;
} }
/* lookup symbol in given range of kernel_symbols */
static const struct kernel_symbol *lookup_symbol(const char *name,
const struct kernel_symbol *start,
const struct kernel_symbol *stop)
{
const struct kernel_symbol *ks = start;
for (; ks < stop; ks++)
if (strcmp(ks->name, name) == 0)
return ks;
return NULL;
}
/* Search for module by name: must hold module_mutex. */ /* Search for module by name: must hold module_mutex. */
static struct module *find_module(const char *name) static struct module *find_module(const char *name)
{ {