blob: 5f7a8b663cb9c9eb59b32f4ce63076a6a86914cc [file] [log] [blame]
David Daneya79f2482012-04-19 14:59:55 -07001/*
2 * sortextable.c: Sort the kernel's exception table
3 *
David Daneyd59a1682012-04-24 11:23:14 -07004 * Copyright 2011 - 2012 Cavium, Inc.
David Daneya79f2482012-04-19 14:59:55 -07005 *
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
David Daneyd59a1682012-04-24 11:23:14 -070031#include <tools/be_byteshift.h>
32#include <tools/le_byteshift.h>
33
Will Deaconadace892013-05-08 17:29:24 +010034#ifndef EM_AARCH64
35#define EM_AARCH64 183
36#endif
37
David Daneya79f2482012-04-19 14:59:55 -070038static int fd_map; /* File descriptor for file being modified. */
39static int mmap_failed; /* Boolean flag. */
40static void *ehdr_curr; /* current ElfXX_Ehdr * for resource cleanup */
41static struct stat sb; /* Remember .st_size, etc. */
42static jmp_buf jmpenv; /* setjmp/longjmp per-file error escape */
43
44/* setjmp() return values */
45enum {
46 SJ_SETJMP = 0, /* hardwired first return */
47 SJ_FAIL,
48 SJ_SUCCEED
49};
50
51/* Per-file resource cleanup when multiple files. */
52static void
53cleanup(void)
54{
55 if (!mmap_failed)
56 munmap(ehdr_curr, sb.st_size);
57 close(fd_map);
58}
59
60static void __attribute__((noreturn))
61fail_file(void)
62{
63 cleanup();
64 longjmp(jmpenv, SJ_FAIL);
65}
66
David Daneya79f2482012-04-19 14:59:55 -070067/*
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 */
73static 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
David Daneyd59a1682012-04-24 11:23:14 -070096static uint64_t r8be(const uint64_t *x)
David Daneya79f2482012-04-19 14:59:55 -070097{
David Daneyd59a1682012-04-24 11:23:14 -070098 return get_unaligned_be64(x);
99}
100static uint32_t rbe(const uint32_t *x)
101{
102 return get_unaligned_be32(x);
103}
104static uint16_t r2be(const uint16_t *x)
105{
106 return get_unaligned_be16(x);
107}
108static uint64_t r8le(const uint64_t *x)
109{
110 return get_unaligned_le64(x);
111}
112static uint32_t rle(const uint32_t *x)
113{
114 return get_unaligned_le32(x);
115}
116static uint16_t r2le(const uint16_t *x)
117{
118 return get_unaligned_le16(x);
David Daneya79f2482012-04-19 14:59:55 -0700119}
120
David Daneyd59a1682012-04-24 11:23:14 -0700121static void w8be(uint64_t val, uint64_t *x)
David Daneya79f2482012-04-19 14:59:55 -0700122{
David Daneyd59a1682012-04-24 11:23:14 -0700123 put_unaligned_be64(val, x);
124}
125static void wbe(uint32_t val, uint32_t *x)
126{
127 put_unaligned_be32(val, x);
128}
129static void w2be(uint16_t val, uint16_t *x)
130{
131 put_unaligned_be16(val, x);
132}
133static void w8le(uint64_t val, uint64_t *x)
134{
135 put_unaligned_le64(val, x);
136}
137static void wle(uint32_t val, uint32_t *x)
138{
139 put_unaligned_le32(val, x);
140}
141static void w2le(uint16_t val, uint16_t *x)
142{
143 put_unaligned_le16(val, x);
David Daneya79f2482012-04-19 14:59:55 -0700144}
145
David Daneyd59a1682012-04-24 11:23:14 -0700146static uint64_t (*r8)(const uint64_t *);
147static uint32_t (*r)(const uint32_t *);
148static uint16_t (*r2)(const uint16_t *);
149static void (*w8)(uint64_t, uint64_t *);
150static void (*w)(uint32_t, uint32_t *);
151static void (*w2)(uint16_t, uint16_t *);
David Daneya79f2482012-04-19 14:59:55 -0700152
David Daneyd59a1682012-04-24 11:23:14 -0700153typedef void (*table_sort_t)(char *, int);
David Daneya79f2482012-04-19 14:59:55 -0700154
Jamie Iles59c36452013-11-12 15:06:51 -0800155/*
156 * Move reserved section indices SHN_LORESERVE..SHN_HIRESERVE out of
157 * the way to -256..-1, to avoid conflicting with real section
158 * indices.
159 */
160#define SPECIAL(i) ((i) - (SHN_HIRESERVE + 1))
161
162static inline int is_shndx_special(unsigned int i)
163{
164 return i != SHN_XINDEX && i >= SHN_LORESERVE && i <= SHN_HIRESERVE;
165}
166
167/* Accessor for sym->st_shndx, hides ugliness of "64k sections" */
168static inline unsigned int get_secindex(unsigned int shndx,
169 unsigned int sym_offs,
170 const Elf32_Word *symtab_shndx_start)
171{
172 if (is_shndx_special(shndx))
173 return SPECIAL(shndx);
174 if (shndx != SHN_XINDEX)
175 return shndx;
176 return r(&symtab_shndx_start[sym_offs]);
177}
178
David Daneya79f2482012-04-19 14:59:55 -0700179/* 32 bit and 64 bit are very similar */
180#include "sortextable.h"
181#define SORTEXTABLE_64
182#include "sortextable.h"
183
Heiko Carstenseb608fb2012-09-05 13:26:11 +0200184static int compare_relative_table(const void *a, const void *b)
David Daneyd59a1682012-04-24 11:23:14 -0700185{
186 int32_t av = (int32_t)r(a);
187 int32_t bv = (int32_t)r(b);
188
189 if (av < bv)
190 return -1;
191 if (av > bv)
192 return 1;
193 return 0;
194}
195
Heiko Carstenseb608fb2012-09-05 13:26:11 +0200196static void sort_relative_table(char *extab_image, int image_size)
David Daneyd59a1682012-04-24 11:23:14 -0700197{
198 int i;
199
200 /*
201 * Do the same thing the runtime sort does, first normalize to
202 * being relative to the start of the section.
203 */
204 i = 0;
205 while (i < image_size) {
206 uint32_t *loc = (uint32_t *)(extab_image + i);
207 w(r(loc) + i, loc);
208 i += 4;
209 }
210
Heiko Carstenseb608fb2012-09-05 13:26:11 +0200211 qsort(extab_image, image_size / 8, 8, compare_relative_table);
David Daneyd59a1682012-04-24 11:23:14 -0700212
213 /* Now denormalize. */
214 i = 0;
215 while (i < image_size) {
216 uint32_t *loc = (uint32_t *)(extab_image + i);
217 w(r(loc) - i, loc);
218 i += 4;
219 }
220}
David Daneya79f2482012-04-19 14:59:55 -0700221
222static void
223do_file(char const *const fname)
224{
David Daneyd59a1682012-04-24 11:23:14 -0700225 table_sort_t custom_sort;
226 Elf32_Ehdr *ehdr = mmap_file(fname);
David Daneya79f2482012-04-19 14:59:55 -0700227
228 ehdr_curr = ehdr;
David Daneya79f2482012-04-19 14:59:55 -0700229 switch (ehdr->e_ident[EI_DATA]) {
David Daneya79f2482012-04-19 14:59:55 -0700230 default:
231 fprintf(stderr, "unrecognized ELF data encoding %d: %s\n",
232 ehdr->e_ident[EI_DATA], fname);
233 fail_file();
234 break;
235 case ELFDATA2LSB:
David Daneyd59a1682012-04-24 11:23:14 -0700236 r = rle;
237 r2 = r2le;
238 r8 = r8le;
239 w = wle;
240 w2 = w2le;
241 w8 = w8le;
David Daneya79f2482012-04-19 14:59:55 -0700242 break;
243 case ELFDATA2MSB:
David Daneyd59a1682012-04-24 11:23:14 -0700244 r = rbe;
245 r2 = r2be;
246 r8 = r8be;
247 w = wbe;
248 w2 = w2be;
249 w8 = w8be;
David Daneya79f2482012-04-19 14:59:55 -0700250 break;
251 } /* end switch */
252 if (memcmp(ELFMAG, ehdr->e_ident, SELFMAG) != 0
David Daneyd59a1682012-04-24 11:23:14 -0700253 || r2(&ehdr->e_type) != ET_EXEC
David Daneya79f2482012-04-19 14:59:55 -0700254 || ehdr->e_ident[EI_VERSION] != EV_CURRENT) {
255 fprintf(stderr, "unrecognized ET_EXEC file %s\n", fname);
256 fail_file();
257 }
258
David Daneyd59a1682012-04-24 11:23:14 -0700259 custom_sort = NULL;
260 switch (r2(&ehdr->e_machine)) {
David Daneya79f2482012-04-19 14:59:55 -0700261 default:
262 fprintf(stderr, "unrecognized e_machine %d %s\n",
David Daneyd59a1682012-04-24 11:23:14 -0700263 r2(&ehdr->e_machine), fname);
David Daneya79f2482012-04-19 14:59:55 -0700264 fail_file();
265 break;
266 case EM_386:
David Daneya79f2482012-04-19 14:59:55 -0700267 case EM_X86_64:
Heiko Carstens3193a982012-07-24 14:51:34 +0200268 case EM_S390:
Heiko Carstenseb608fb2012-09-05 13:26:11 +0200269 custom_sort = sort_relative_table;
270 break;
Stephen Boydee951c62012-10-29 19:19:34 +0100271 case EM_ARM:
Will Deaconadace892013-05-08 17:29:24 +0100272 case EM_AARCH64:
David Daneyd59a1682012-04-24 11:23:14 -0700273 case EM_MIPS:
David Daneya79f2482012-04-19 14:59:55 -0700274 break;
275 } /* end switch */
276
277 switch (ehdr->e_ident[EI_CLASS]) {
278 default:
279 fprintf(stderr, "unrecognized ELF class %d %s\n",
280 ehdr->e_ident[EI_CLASS], fname);
281 fail_file();
282 break;
283 case ELFCLASS32:
David Daneyd59a1682012-04-24 11:23:14 -0700284 if (r2(&ehdr->e_ehsize) != sizeof(Elf32_Ehdr)
285 || r2(&ehdr->e_shentsize) != sizeof(Elf32_Shdr)) {
David Daneya79f2482012-04-19 14:59:55 -0700286 fprintf(stderr,
287 "unrecognized ET_EXEC file: %s\n", fname);
288 fail_file();
289 }
David Daneyd59a1682012-04-24 11:23:14 -0700290 do32(ehdr, fname, custom_sort);
David Daneya79f2482012-04-19 14:59:55 -0700291 break;
292 case ELFCLASS64: {
293 Elf64_Ehdr *const ghdr = (Elf64_Ehdr *)ehdr;
David Daneyd59a1682012-04-24 11:23:14 -0700294 if (r2(&ghdr->e_ehsize) != sizeof(Elf64_Ehdr)
295 || r2(&ghdr->e_shentsize) != sizeof(Elf64_Shdr)) {
David Daneya79f2482012-04-19 14:59:55 -0700296 fprintf(stderr,
297 "unrecognized ET_EXEC file: %s\n", fname);
298 fail_file();
299 }
David Daneyd59a1682012-04-24 11:23:14 -0700300 do64(ghdr, fname, custom_sort);
David Daneya79f2482012-04-19 14:59:55 -0700301 break;
302 }
303 } /* end switch */
304
305 cleanup();
306}
307
308int
309main(int argc, char *argv[])
310{
311 int n_error = 0; /* gcc-4.3.0 false positive complaint */
312 int i;
313
314 if (argc < 2) {
315 fprintf(stderr, "usage: sortextable vmlinux...\n");
316 return 0;
317 }
318
319 /* Process each file in turn, allowing deep failure. */
320 for (i = 1; i < argc; i++) {
321 char *file = argv[i];
322 int const sjval = setjmp(jmpenv);
323
324 switch (sjval) {
325 default:
326 fprintf(stderr, "internal error: %s\n", file);
327 exit(1);
328 break;
329 case SJ_SETJMP: /* normal sequence */
330 /* Avoid problems if early cleanup() */
331 fd_map = -1;
332 ehdr_curr = NULL;
333 mmap_failed = 1;
334 do_file(file);
335 break;
336 case SJ_FAIL: /* error in do_file or below */
337 ++n_error;
338 break;
339 case SJ_SUCCEED: /* premature success */
340 /* do nothing */
341 break;
342 } /* end switch */
343 }
344 return !!n_error;
345}