1 /* 2 * Derived from arch/ppc/mm/extable.c and arch/i386/mm/extable.c. 3 * 4 * Copyright (C) 2004 Paul Mackerras, IBM Corp. 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 9 * 2 of the License, or (at your option) any later version. 10 */ 11 12 #include <linux/bsearch.h> 13 #include <linux/module.h> 14 #include <linux/init.h> 15 #include <linux/sort.h> 16 #include <linux/uaccess.h> 17 18 #ifndef ARCH_HAS_RELATIVE_EXTABLE 19 #define ex_to_insn(x) ((x)->insn) 20 #else 21 static inline unsigned long ex_to_insn(const struct exception_table_entry *x) 22 { 23 return (unsigned long)&x->insn + x->insn; 24 } 25 #endif 26 27 #ifndef ARCH_HAS_SORT_EXTABLE 28 #ifndef ARCH_HAS_RELATIVE_EXTABLE 29 #define swap_ex NULL 30 #else 31 static void swap_ex(void *a, void *b, int size) 32 { 33 struct exception_table_entry *x = a, *y = b, tmp; 34 int delta = b - a; 35 36 tmp = *x; 37 x->insn = y->insn + delta; 38 y->insn = tmp.insn - delta; 39 40 #ifdef swap_ex_entry_fixup 41 swap_ex_entry_fixup(x, y, tmp, delta); 42 #else 43 x->fixup = y->fixup + delta; 44 y->fixup = tmp.fixup - delta; 45 #endif 46 } 47 #endif /* ARCH_HAS_RELATIVE_EXTABLE */ 48 49 /* 50 * The exception table needs to be sorted so that the binary 51 * search that we use to find entries in it works properly. 52 * This is used both for the kernel exception table and for 53 * the exception tables of modules that get loaded. 54 */ 55 static int cmp_ex_sort(const void *a, const void *b) 56 { 57 const struct exception_table_entry *x = a, *y = b; 58 59 /* avoid overflow */ 60 if (ex_to_insn(x) > ex_to_insn(y)) 61 return 1; 62 if (ex_to_insn(x) < ex_to_insn(y)) 63 return -1; 64 return 0; 65 } 66 67 void sort_extable(struct exception_table_entry *start, 68 struct exception_table_entry *finish) 69 { 70 sort(start, finish - start, sizeof(struct exception_table_entry), 71 cmp_ex_sort, swap_ex); 72 } 73 74 #ifdef CONFIG_MODULES 75 /* 76 * If the exception table is sorted, any referring to the module init 77 * will be at the beginning or the end. 78 */ 79 void trim_init_extable(struct module *m) 80 { 81 /*trim the beginning*/ 82 while (m->num_exentries && 83 within_module_init(ex_to_insn(&m->extable[0]), m)) { 84 m->extable++; 85 m->num_exentries--; 86 } 87 /*trim the end*/ 88 while (m->num_exentries && 89 within_module_init(ex_to_insn(&m->extable[m->num_exentries - 1]), 90 m)) 91 m->num_exentries--; 92 } 93 #endif /* CONFIG_MODULES */ 94 #endif /* !ARCH_HAS_SORT_EXTABLE */ 95 96 #ifndef ARCH_HAS_SEARCH_EXTABLE 97 98 static int cmp_ex_search(const void *key, const void *elt) 99 { 100 const struct exception_table_entry *_elt = elt; 101 unsigned long _key = *(unsigned long *)key; 102 103 /* avoid overflow */ 104 if (_key > ex_to_insn(_elt)) 105 return 1; 106 if (_key < ex_to_insn(_elt)) 107 return -1; 108 return 0; 109 } 110 111 /* 112 * Search one exception table for an entry corresponding to the 113 * given instruction address, and return the address of the entry, 114 * or NULL if none is found. 115 * We use a binary search, and thus we assume that the table is 116 * already sorted. 117 */ 118 const struct exception_table_entry * 119 search_extable(const struct exception_table_entry *base, 120 const size_t num, 121 unsigned long value) 122 { 123 return bsearch(&value, base, num, 124 sizeof(struct exception_table_entry), cmp_ex_search); 125 } 126 #endif 127