mirror of
https://github.com/torvalds/linux.git
synced 2024-11-11 06:31:49 +00:00
ad6561dffa
It's theoretically possible that there are exception table entries which point into the (freed) init text of modules. These could cause future problems if other modules get loaded into that memory and cause an exception as we'd see the wrong fixup. The only case I know of is kvm-intel.ko (when CONFIG_CC_OPTIMIZE_FOR_SIZE=n). Amerigo fixed this long-standing FIXME in the x86 version, but this patch is more general. This implements trim_init_extable(); most archs are simple since they use the standard lib/extable.c sort code. Alpha and IA64 use relative addresses in their fixups, so thier trimming is a slight variation. Sparc32 is unique; it doesn't seem to define ARCH_HAS_SORT_EXTABLE, yet it defines its own sort_extable() which overrides the one in lib. It doesn't sort, so we have to mark deleted entries instead of actually trimming them. Inspired-by: Amerigo Wang <amwang@redhat.com> Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> Cc: linux-alpha@vger.kernel.org Cc: sparclinux@vger.kernel.org Cc: linux-ia64@vger.kernel.org
93 lines
2.3 KiB
C
93 lines
2.3 KiB
C
/*
|
|
* linux/arch/alpha/mm/extable.c
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/sort.h>
|
|
#include <asm/uaccess.h>
|
|
|
|
static inline unsigned long ex_to_addr(const struct exception_table_entry *x)
|
|
{
|
|
return (unsigned long)&x->insn + x->insn;
|
|
}
|
|
|
|
static void swap_ex(void *a, void *b, int size)
|
|
{
|
|
struct exception_table_entry *ex_a = a, *ex_b = b;
|
|
unsigned long addr_a = ex_to_addr(ex_a), addr_b = ex_to_addr(ex_b);
|
|
unsigned int t = ex_a->fixup.unit;
|
|
|
|
ex_a->fixup.unit = ex_b->fixup.unit;
|
|
ex_b->fixup.unit = t;
|
|
ex_a->insn = (int)(addr_b - (unsigned long)&ex_a->insn);
|
|
ex_b->insn = (int)(addr_a - (unsigned long)&ex_b->insn);
|
|
}
|
|
|
|
/*
|
|
* The exception table needs to be sorted so that the binary
|
|
* search that we use to find entries in it works properly.
|
|
* This is used both for the kernel exception table and for
|
|
* the exception tables of modules that get loaded.
|
|
*/
|
|
static int cmp_ex(const void *a, const void *b)
|
|
{
|
|
const struct exception_table_entry *x = a, *y = b;
|
|
|
|
/* avoid overflow */
|
|
if (ex_to_addr(x) > ex_to_addr(y))
|
|
return 1;
|
|
if (ex_to_addr(x) < ex_to_addr(y))
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
void sort_extable(struct exception_table_entry *start,
|
|
struct exception_table_entry *finish)
|
|
{
|
|
sort(start, finish - start, sizeof(struct exception_table_entry),
|
|
cmp_ex, swap_ex);
|
|
}
|
|
|
|
#ifdef CONFIG_MODULES
|
|
/*
|
|
* Any entry referring to the module init will be at the beginning or
|
|
* the end.
|
|
*/
|
|
void trim_init_extable(struct module *m)
|
|
{
|
|
/*trim the beginning*/
|
|
while (m->num_exentries &&
|
|
within_module_init(ex_to_addr(&m->extable[0]), m)) {
|
|
m->extable++;
|
|
m->num_exentries--;
|
|
}
|
|
/*trim the end*/
|
|
while (m->num_exentries &&
|
|
within_module_init(ex_to_addr(&m->extable[m->num_exentries-1]),
|
|
m))
|
|
m->num_exentries--;
|
|
}
|
|
#endif /* CONFIG_MODULES */
|
|
|
|
const struct exception_table_entry *
|
|
search_extable(const struct exception_table_entry *first,
|
|
const struct exception_table_entry *last,
|
|
unsigned long value)
|
|
{
|
|
while (first <= last) {
|
|
const struct exception_table_entry *mid;
|
|
unsigned long mid_value;
|
|
|
|
mid = (last - first) / 2 + first;
|
|
mid_value = ex_to_addr(mid);
|
|
if (mid_value == value)
|
|
return mid;
|
|
else if (mid_value < value)
|
|
first = mid+1;
|
|
else
|
|
last = mid-1;
|
|
}
|
|
|
|
return NULL;
|
|
}
|