Root/
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_AARCH64 |
35 | #define EM_AARCH64 183 |
36 | #endif |
37 | |
38 | static int fd_map; /* File descriptor for file being modified. */ |
39 | static int mmap_failed; /* Boolean flag. */ |
40 | static void *ehdr_curr; /* current ElfXX_Ehdr * for resource cleanup */ |
41 | static struct stat sb; /* Remember .st_size, etc. */ |
42 | static jmp_buf jmpenv; /* setjmp/longjmp per-file error escape */ |
43 | |
44 | /* setjmp() return values */ |
45 | enum { |
46 | SJ_SETJMP = 0, /* hardwired first return */ |
47 | SJ_FAIL, |
48 | SJ_SUCCEED |
49 | }; |
50 | |
51 | /* Per-file resource cleanup when multiple files. */ |
52 | static void |
53 | cleanup(void) |
54 | { |
55 | if (!mmap_failed) |
56 | munmap(ehdr_curr, sb.st_size); |
57 | close(fd_map); |
58 | } |
59 | |
60 | static void __attribute__((noreturn)) |
61 | fail_file(void) |
62 | { |
63 | cleanup(); |
64 | longjmp(jmpenv, SJ_FAIL); |
65 | } |
66 | |
67 | /* |
68 | * Get the whole file as a programming convenience in order to avoid |
69 | * malloc+lseek+read+free of many pieces. If successful, then mmap |
70 | * avoids copying unused pieces; else just read the whole file. |
71 | * Open for both read and write. |
72 | */ |
73 | static void *mmap_file(char const *fname) |
74 | { |
75 | void *addr; |
76 | |
77 | fd_map = open(fname, O_RDWR); |
78 | if (fd_map < 0 || fstat(fd_map, &sb) < 0) { |
79 | perror(fname); |
80 | fail_file(); |
81 | } |
82 | if (!S_ISREG(sb.st_mode)) { |
83 | fprintf(stderr, "not a regular file: %s\n", fname); |
84 | fail_file(); |
85 | } |
86 | addr = mmap(0, sb.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, |
87 | fd_map, 0); |
88 | if (addr == MAP_FAILED) { |
89 | mmap_failed = 1; |
90 | fprintf(stderr, "Could not mmap file: %s\n", fname); |
91 | fail_file(); |
92 | } |
93 | return addr; |
94 | } |
95 | |
96 | static uint64_t r8be(const uint64_t *x) |
97 | { |
98 | return get_unaligned_be64(x); |
99 | } |
100 | static uint32_t rbe(const uint32_t *x) |
101 | { |
102 | return get_unaligned_be32(x); |
103 | } |
104 | static uint16_t r2be(const uint16_t *x) |
105 | { |
106 | return get_unaligned_be16(x); |
107 | } |
108 | static uint64_t r8le(const uint64_t *x) |
109 | { |
110 | return get_unaligned_le64(x); |
111 | } |
112 | static uint32_t rle(const uint32_t *x) |
113 | { |
114 | return get_unaligned_le32(x); |
115 | } |
116 | static uint16_t r2le(const uint16_t *x) |
117 | { |
118 | return get_unaligned_le16(x); |
119 | } |
120 | |
121 | static void w8be(uint64_t val, uint64_t *x) |
122 | { |
123 | put_unaligned_be64(val, x); |
124 | } |
125 | static void wbe(uint32_t val, uint32_t *x) |
126 | { |
127 | put_unaligned_be32(val, x); |
128 | } |
129 | static void w2be(uint16_t val, uint16_t *x) |
130 | { |
131 | put_unaligned_be16(val, x); |
132 | } |
133 | static void w8le(uint64_t val, uint64_t *x) |
134 | { |
135 | put_unaligned_le64(val, x); |
136 | } |
137 | static void wle(uint32_t val, uint32_t *x) |
138 | { |
139 | put_unaligned_le32(val, x); |
140 | } |
141 | static void w2le(uint16_t val, uint16_t *x) |
142 | { |
143 | put_unaligned_le16(val, x); |
144 | } |
145 | |
146 | static uint64_t (*r8)(const uint64_t *); |
147 | static uint32_t (*r)(const uint32_t *); |
148 | static uint16_t (*r2)(const uint16_t *); |
149 | static void (*w8)(uint64_t, uint64_t *); |
150 | static void (*w)(uint32_t, uint32_t *); |
151 | static void (*w2)(uint16_t, uint16_t *); |
152 | |
153 | typedef void (*table_sort_t)(char *, int); |
154 | |
155 | /* 32 bit and 64 bit are very similar */ |
156 | #include "sortextable.h" |
157 | #define SORTEXTABLE_64 |
158 | #include "sortextable.h" |
159 | |
160 | static int compare_relative_table(const void *a, const void *b) |
161 | { |
162 | int32_t av = (int32_t)r(a); |
163 | int32_t bv = (int32_t)r(b); |
164 | |
165 | if (av < bv) |
166 | return -1; |
167 | if (av > bv) |
168 | return 1; |
169 | return 0; |
170 | } |
171 | |
172 | static void sort_relative_table(char *extab_image, int image_size) |
173 | { |
174 | int i; |
175 | |
176 | /* |
177 | * Do the same thing the runtime sort does, first normalize to |
178 | * being relative to the start of the section. |
179 | */ |
180 | i = 0; |
181 | while (i < image_size) { |
182 | uint32_t *loc = (uint32_t *)(extab_image + i); |
183 | w(r(loc) + i, loc); |
184 | i += 4; |
185 | } |
186 | |
187 | qsort(extab_image, image_size / 8, 8, compare_relative_table); |
188 | |
189 | /* Now denormalize. */ |
190 | i = 0; |
191 | while (i < image_size) { |
192 | uint32_t *loc = (uint32_t *)(extab_image + i); |
193 | w(r(loc) - i, loc); |
194 | i += 4; |
195 | } |
196 | } |
197 | |
198 | static void |
199 | do_file(char const *const fname) |
200 | { |
201 | table_sort_t custom_sort; |
202 | Elf32_Ehdr *ehdr = mmap_file(fname); |
203 | |
204 | ehdr_curr = ehdr; |
205 | switch (ehdr->e_ident[EI_DATA]) { |
206 | default: |
207 | fprintf(stderr, "unrecognized ELF data encoding %d: %s\n", |
208 | ehdr->e_ident[EI_DATA], fname); |
209 | fail_file(); |
210 | break; |
211 | case ELFDATA2LSB: |
212 | r = rle; |
213 | r2 = r2le; |
214 | r8 = r8le; |
215 | w = wle; |
216 | w2 = w2le; |
217 | w8 = w8le; |
218 | break; |
219 | case ELFDATA2MSB: |
220 | r = rbe; |
221 | r2 = r2be; |
222 | r8 = r8be; |
223 | w = wbe; |
224 | w2 = w2be; |
225 | w8 = w8be; |
226 | break; |
227 | } /* end switch */ |
228 | if (memcmp(ELFMAG, ehdr->e_ident, SELFMAG) != 0 |
229 | || r2(&ehdr->e_type) != ET_EXEC |
230 | || ehdr->e_ident[EI_VERSION] != EV_CURRENT) { |
231 | fprintf(stderr, "unrecognized ET_EXEC file %s\n", fname); |
232 | fail_file(); |
233 | } |
234 | |
235 | custom_sort = NULL; |
236 | switch (r2(&ehdr->e_machine)) { |
237 | default: |
238 | fprintf(stderr, "unrecognized e_machine %d %s\n", |
239 | r2(&ehdr->e_machine), fname); |
240 | fail_file(); |
241 | break; |
242 | case EM_386: |
243 | case EM_X86_64: |
244 | case EM_S390: |
245 | custom_sort = sort_relative_table; |
246 | break; |
247 | case EM_ARM: |
248 | case EM_AARCH64: |
249 | case EM_MIPS: |
250 | break; |
251 | } /* end switch */ |
252 | |
253 | switch (ehdr->e_ident[EI_CLASS]) { |
254 | default: |
255 | fprintf(stderr, "unrecognized ELF class %d %s\n", |
256 | ehdr->e_ident[EI_CLASS], fname); |
257 | fail_file(); |
258 | break; |
259 | case ELFCLASS32: |
260 | if (r2(&ehdr->e_ehsize) != sizeof(Elf32_Ehdr) |
261 | || r2(&ehdr->e_shentsize) != sizeof(Elf32_Shdr)) { |
262 | fprintf(stderr, |
263 | "unrecognized ET_EXEC file: %s\n", fname); |
264 | fail_file(); |
265 | } |
266 | do32(ehdr, fname, custom_sort); |
267 | break; |
268 | case ELFCLASS64: { |
269 | Elf64_Ehdr *const ghdr = (Elf64_Ehdr *)ehdr; |
270 | if (r2(&ghdr->e_ehsize) != sizeof(Elf64_Ehdr) |
271 | || r2(&ghdr->e_shentsize) != sizeof(Elf64_Shdr)) { |
272 | fprintf(stderr, |
273 | "unrecognized ET_EXEC file: %s\n", fname); |
274 | fail_file(); |
275 | } |
276 | do64(ghdr, fname, custom_sort); |
277 | break; |
278 | } |
279 | } /* end switch */ |
280 | |
281 | cleanup(); |
282 | } |
283 | |
284 | int |
285 | main(int argc, char *argv[]) |
286 | { |
287 | int n_error = 0; /* gcc-4.3.0 false positive complaint */ |
288 | int i; |
289 | |
290 | if (argc < 2) { |
291 | fprintf(stderr, "usage: sortextable vmlinux...\n"); |
292 | return 0; |
293 | } |
294 | |
295 | /* Process each file in turn, allowing deep failure. */ |
296 | for (i = 1; i < argc; i++) { |
297 | char *file = argv[i]; |
298 | int const sjval = setjmp(jmpenv); |
299 | |
300 | switch (sjval) { |
301 | default: |
302 | fprintf(stderr, "internal error: %s\n", file); |
303 | exit(1); |
304 | break; |
305 | case SJ_SETJMP: /* normal sequence */ |
306 | /* Avoid problems if early cleanup() */ |
307 | fd_map = -1; |
308 | ehdr_curr = NULL; |
309 | mmap_failed = 1; |
310 | do_file(file); |
311 | break; |
312 | case SJ_FAIL: /* error in do_file or below */ |
313 | ++n_error; |
314 | break; |
315 | case SJ_SUCCEED: /* premature success */ |
316 | /* do nothing */ |
317 | break; |
318 | } /* end switch */ |
319 | } |
320 | return !!n_error; |
321 | } |
322 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9