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