Commit | Line | Data |
---|---|---|
a79f248b DD |
1 | /* |
2 | * sortextable.c: Sort the kernel's exception table | |
3 | * | |
d59a1683 | 4 | * Copyright 2011 - 2012 Cavium, Inc. |
a79f248b DD |
5 | * |
6 | * Based on code taken from recortmcount.c which is: | |
7 | * | |
8 | * Copyright 2009 John F. Reiser <jreiser@BitWagon.com>. All rights reserved. | |
9 | * Licensed under the GNU General Public License, version 2 (GPLv2). | |
10 | * | |
11 | * Restructured to fit Linux format, as well as other updates: | |
12 | * Copyright 2010 Steven Rostedt <srostedt@redhat.com>, Red Hat Inc. | |
13 | */ | |
14 | ||
15 | /* | |
16 | * Strategy: alter the vmlinux file in-place. | |
17 | */ | |
18 | ||
19 | #include <sys/types.h> | |
20 | #include <sys/mman.h> | |
21 | #include <sys/stat.h> | |
22 | #include <getopt.h> | |
23 | #include <elf.h> | |
24 | #include <fcntl.h> | |
25 | #include <setjmp.h> | |
26 | #include <stdio.h> | |
27 | #include <stdlib.h> | |
28 | #include <string.h> | |
29 | #include <unistd.h> | |
30 | ||
d59a1683 DD |
31 | #include <tools/be_byteshift.h> |
32 | #include <tools/le_byteshift.h> | |
33 | ||
f06d19e4 VG |
34 | #ifndef EM_ARCOMPACT |
35 | #define EM_ARCOMPACT 93 | |
36 | #endif | |
37 | ||
adace895 WD |
38 | #ifndef EM_AARCH64 |
39 | #define EM_AARCH64 183 | |
40 | #endif | |
41 | ||
a79f248b DD |
42 | static int fd_map; /* File descriptor for file being modified. */ |
43 | static int mmap_failed; /* Boolean flag. */ | |
44 | static void *ehdr_curr; /* current ElfXX_Ehdr * for resource cleanup */ | |
45 | static struct stat sb; /* Remember .st_size, etc. */ | |
46 | static jmp_buf jmpenv; /* setjmp/longjmp per-file error escape */ | |
47 | ||
48 | /* setjmp() return values */ | |
49 | enum { | |
50 | SJ_SETJMP = 0, /* hardwired first return */ | |
51 | SJ_FAIL, | |
52 | SJ_SUCCEED | |
53 | }; | |
54 | ||
55 | /* Per-file resource cleanup when multiple files. */ | |
56 | static void | |
57 | cleanup(void) | |
58 | { | |
59 | if (!mmap_failed) | |
60 | munmap(ehdr_curr, sb.st_size); | |
61 | close(fd_map); | |
62 | } | |
63 | ||
64 | static void __attribute__((noreturn)) | |
65 | fail_file(void) | |
66 | { | |
67 | cleanup(); | |
68 | longjmp(jmpenv, SJ_FAIL); | |
69 | } | |
70 | ||
a79f248b DD |
71 | /* |
72 | * Get the whole file as a programming convenience in order to avoid | |
73 | * malloc+lseek+read+free of many pieces. If successful, then mmap | |
74 | * avoids copying unused pieces; else just read the whole file. | |
75 | * Open for both read and write. | |
76 | */ | |
77 | static void *mmap_file(char const *fname) | |
78 | { | |
79 | void *addr; | |
80 | ||
81 | fd_map = open(fname, O_RDWR); | |
82 | if (fd_map < 0 || fstat(fd_map, &sb) < 0) { | |
83 | perror(fname); | |
84 | fail_file(); | |
85 | } | |
86 | if (!S_ISREG(sb.st_mode)) { | |
87 | fprintf(stderr, "not a regular file: %s\n", fname); | |
88 | fail_file(); | |
89 | } | |
90 | addr = mmap(0, sb.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, | |
91 | fd_map, 0); | |
92 | if (addr == MAP_FAILED) { | |
93 | mmap_failed = 1; | |
94 | fprintf(stderr, "Could not mmap file: %s\n", fname); | |
95 | fail_file(); | |
96 | } | |
97 | return addr; | |
98 | } | |
99 | ||
d59a1683 | 100 | static uint64_t r8be(const uint64_t *x) |
a79f248b | 101 | { |
d59a1683 | 102 | return get_unaligned_be64(x); |
a79f248b | 103 | } |
d59a1683 | 104 | static uint32_t rbe(const uint32_t *x) |
a79f248b | 105 | { |
d59a1683 | 106 | return get_unaligned_be32(x); |
a79f248b | 107 | } |
d59a1683 | 108 | static uint16_t r2be(const uint16_t *x) |
a79f248b | 109 | { |
d59a1683 | 110 | return get_unaligned_be16(x); |
a79f248b | 111 | } |
d59a1683 | 112 | static uint64_t r8le(const uint64_t *x) |
a79f248b | 113 | { |
d59a1683 | 114 | return get_unaligned_le64(x); |
a79f248b | 115 | } |
d59a1683 DD |
116 | static uint32_t rle(const uint32_t *x) |
117 | { | |
118 | return get_unaligned_le32(x); | |
119 | } | |
120 | static uint16_t r2le(const uint16_t *x) | |
a79f248b | 121 | { |
d59a1683 | 122 | return get_unaligned_le16(x); |
a79f248b DD |
123 | } |
124 | ||
d59a1683 DD |
125 | static void w8be(uint64_t val, uint64_t *x) |
126 | { | |
127 | put_unaligned_be64(val, x); | |
128 | } | |
129 | static void wbe(uint32_t val, uint32_t *x) | |
130 | { | |
131 | put_unaligned_be32(val, x); | |
132 | } | |
133 | static void w2be(uint16_t val, uint16_t *x) | |
134 | { | |
135 | put_unaligned_be16(val, x); | |
136 | } | |
137 | static void w8le(uint64_t val, uint64_t *x) | |
138 | { | |
139 | put_unaligned_le64(val, x); | |
140 | } | |
141 | static void wle(uint32_t val, uint32_t *x) | |
142 | { | |
143 | put_unaligned_le32(val, x); | |
144 | } | |
145 | static void w2le(uint16_t val, uint16_t *x) | |
a79f248b | 146 | { |
d59a1683 | 147 | put_unaligned_le16(val, x); |
a79f248b DD |
148 | } |
149 | ||
d59a1683 DD |
150 | static uint64_t (*r8)(const uint64_t *); |
151 | static uint32_t (*r)(const uint32_t *); | |
152 | static uint16_t (*r2)(const uint16_t *); | |
153 | static void (*w8)(uint64_t, uint64_t *); | |
154 | static void (*w)(uint32_t, uint32_t *); | |
155 | static void (*w2)(uint16_t, uint16_t *); | |
a79f248b | 156 | |
d59a1683 | 157 | typedef void (*table_sort_t)(char *, int); |
a79f248b | 158 | |
59c36455 JI |
159 | /* |
160 | * Move reserved section indices SHN_LORESERVE..SHN_HIRESERVE out of | |
161 | * the way to -256..-1, to avoid conflicting with real section | |
162 | * indices. | |
163 | */ | |
164 | #define SPECIAL(i) ((i) - (SHN_HIRESERVE + 1)) | |
165 | ||
166 | static inline int is_shndx_special(unsigned int i) | |
167 | { | |
168 | return i != SHN_XINDEX && i >= SHN_LORESERVE && i <= SHN_HIRESERVE; | |
169 | } | |
170 | ||
171 | /* Accessor for sym->st_shndx, hides ugliness of "64k sections" */ | |
172 | static inline unsigned int get_secindex(unsigned int shndx, | |
173 | unsigned int sym_offs, | |
174 | const Elf32_Word *symtab_shndx_start) | |
175 | { | |
176 | if (is_shndx_special(shndx)) | |
177 | return SPECIAL(shndx); | |
178 | if (shndx != SHN_XINDEX) | |
179 | return shndx; | |
180 | return r(&symtab_shndx_start[sym_offs]); | |
181 | } | |
182 | ||
a79f248b DD |
183 | /* 32 bit and 64 bit are very similar */ |
184 | #include "sortextable.h" | |
185 | #define SORTEXTABLE_64 | |
186 | #include "sortextable.h" | |
187 | ||
eb608fb3 | 188 | static int compare_relative_table(const void *a, const void *b) |
d59a1683 DD |
189 | { |
190 | int32_t av = (int32_t)r(a); | |
191 | int32_t bv = (int32_t)r(b); | |
192 | ||
193 | if (av < bv) | |
194 | return -1; | |
195 | if (av > bv) | |
196 | return 1; | |
197 | return 0; | |
198 | } | |
199 | ||
eb608fb3 | 200 | static void sort_relative_table(char *extab_image, int image_size) |
d59a1683 DD |
201 | { |
202 | int i; | |
203 | ||
204 | /* | |
205 | * Do the same thing the runtime sort does, first normalize to | |
206 | * being relative to the start of the section. | |
207 | */ | |
208 | i = 0; | |
209 | while (i < image_size) { | |
210 | uint32_t *loc = (uint32_t *)(extab_image + i); | |
211 | w(r(loc) + i, loc); | |
212 | i += 4; | |
213 | } | |
214 | ||
eb608fb3 | 215 | qsort(extab_image, image_size / 8, 8, compare_relative_table); |
d59a1683 DD |
216 | |
217 | /* Now denormalize. */ | |
218 | i = 0; | |
219 | while (i < image_size) { | |
220 | uint32_t *loc = (uint32_t *)(extab_image + i); | |
221 | w(r(loc) - i, loc); | |
222 | i += 4; | |
223 | } | |
224 | } | |
a79f248b DD |
225 | |
226 | static void | |
227 | do_file(char const *const fname) | |
228 | { | |
d59a1683 DD |
229 | table_sort_t custom_sort; |
230 | Elf32_Ehdr *ehdr = mmap_file(fname); | |
a79f248b DD |
231 | |
232 | ehdr_curr = ehdr; | |
a79f248b | 233 | switch (ehdr->e_ident[EI_DATA]) { |
a79f248b DD |
234 | default: |
235 | fprintf(stderr, "unrecognized ELF data encoding %d: %s\n", | |
236 | ehdr->e_ident[EI_DATA], fname); | |
237 | fail_file(); | |
238 | break; | |
239 | case ELFDATA2LSB: | |
d59a1683 DD |
240 | r = rle; |
241 | r2 = r2le; | |
242 | r8 = r8le; | |
243 | w = wle; | |
244 | w2 = w2le; | |
245 | w8 = w8le; | |
a79f248b DD |
246 | break; |
247 | case ELFDATA2MSB: | |
d59a1683 DD |
248 | r = rbe; |
249 | r2 = r2be; | |
250 | r8 = r8be; | |
251 | w = wbe; | |
252 | w2 = w2be; | |
253 | w8 = w8be; | |
a79f248b DD |
254 | break; |
255 | } /* end switch */ | |
256 | if (memcmp(ELFMAG, ehdr->e_ident, SELFMAG) != 0 | |
d59a1683 | 257 | || r2(&ehdr->e_type) != ET_EXEC |
a79f248b DD |
258 | || ehdr->e_ident[EI_VERSION] != EV_CURRENT) { |
259 | fprintf(stderr, "unrecognized ET_EXEC file %s\n", fname); | |
260 | fail_file(); | |
261 | } | |
262 | ||
d59a1683 DD |
263 | custom_sort = NULL; |
264 | switch (r2(&ehdr->e_machine)) { | |
a79f248b DD |
265 | default: |
266 | fprintf(stderr, "unrecognized e_machine %d %s\n", | |
d59a1683 | 267 | r2(&ehdr->e_machine), fname); |
a79f248b DD |
268 | fail_file(); |
269 | break; | |
270 | case EM_386: | |
a79f248b | 271 | case EM_X86_64: |
3193a98d | 272 | case EM_S390: |
eb608fb3 HC |
273 | custom_sort = sort_relative_table; |
274 | break; | |
f06d19e4 | 275 | case EM_ARCOMPACT: |
ee951c63 | 276 | case EM_ARM: |
adace895 | 277 | case EM_AARCH64: |
d59a1683 | 278 | case EM_MIPS: |
a79f248b DD |
279 | break; |
280 | } /* end switch */ | |
281 | ||
282 | switch (ehdr->e_ident[EI_CLASS]) { | |
283 | default: | |
284 | fprintf(stderr, "unrecognized ELF class %d %s\n", | |
285 | ehdr->e_ident[EI_CLASS], fname); | |
286 | fail_file(); | |
287 | break; | |
288 | case ELFCLASS32: | |
d59a1683 DD |
289 | if (r2(&ehdr->e_ehsize) != sizeof(Elf32_Ehdr) |
290 | || r2(&ehdr->e_shentsize) != sizeof(Elf32_Shdr)) { | |
a79f248b DD |
291 | fprintf(stderr, |
292 | "unrecognized ET_EXEC file: %s\n", fname); | |
293 | fail_file(); | |
294 | } | |
d59a1683 | 295 | do32(ehdr, fname, custom_sort); |
a79f248b DD |
296 | break; |
297 | case ELFCLASS64: { | |
298 | Elf64_Ehdr *const ghdr = (Elf64_Ehdr *)ehdr; | |
d59a1683 DD |
299 | if (r2(&ghdr->e_ehsize) != sizeof(Elf64_Ehdr) |
300 | || r2(&ghdr->e_shentsize) != sizeof(Elf64_Shdr)) { | |
a79f248b DD |
301 | fprintf(stderr, |
302 | "unrecognized ET_EXEC file: %s\n", fname); | |
303 | fail_file(); | |
304 | } | |
d59a1683 | 305 | do64(ghdr, fname, custom_sort); |
a79f248b DD |
306 | break; |
307 | } | |
308 | } /* end switch */ | |
309 | ||
310 | cleanup(); | |
311 | } | |
312 | ||
313 | int | |
314 | main(int argc, char *argv[]) | |
315 | { | |
316 | int n_error = 0; /* gcc-4.3.0 false positive complaint */ | |
317 | int i; | |
318 | ||
319 | if (argc < 2) { | |
320 | fprintf(stderr, "usage: sortextable vmlinux...\n"); | |
321 | return 0; | |
322 | } | |
323 | ||
324 | /* Process each file in turn, allowing deep failure. */ | |
325 | for (i = 1; i < argc; i++) { | |
326 | char *file = argv[i]; | |
327 | int const sjval = setjmp(jmpenv); | |
328 | ||
329 | switch (sjval) { | |
330 | default: | |
331 | fprintf(stderr, "internal error: %s\n", file); | |
332 | exit(1); | |
333 | break; | |
334 | case SJ_SETJMP: /* normal sequence */ | |
335 | /* Avoid problems if early cleanup() */ | |
336 | fd_map = -1; | |
337 | ehdr_curr = NULL; | |
338 | mmap_failed = 1; | |
339 | do_file(file); | |
340 | break; | |
341 | case SJ_FAIL: /* error in do_file or below */ | |
342 | ++n_error; | |
343 | break; | |
344 | case SJ_SUCCEED: /* premature success */ | |
345 | /* do nothing */ | |
346 | break; | |
347 | } /* end switch */ | |
348 | } | |
349 | return !!n_error; | |
350 | } |