2
* sortextable.c: Sort the kernel's exception table
4
* Copyright 2011 - 2012 Cavium, Inc.
6
* Based on code taken from recortmcount.c which is:
8
* Copyright 2009 John F. Reiser <jreiser@BitWagon.com>. All rights reserved.
9
* Licensed under the GNU General Public License, version 2 (GPLv2).
11
* Restructured to fit Linux format, as well as other updates:
12
* Copyright 2010 Steven Rostedt <srostedt@redhat.com>, Red Hat Inc.
16
* Strategy: alter the vmlinux file in-place.
19
#include <sys/types.h>
31
#include <tools/be_byteshift.h>
32
#include <tools/le_byteshift.h>
35
#define EM_AARCH64 183
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 */
44
/* setjmp() return values */
46
SJ_SETJMP = 0, /* hardwired first return */
51
/* Per-file resource cleanup when multiple files. */
56
munmap(ehdr_curr, sb.st_size);
60
static void __attribute__((noreturn))
64
longjmp(jmpenv, SJ_FAIL);
67
static void __attribute__((noreturn))
71
longjmp(jmpenv, SJ_SUCCEED);
76
* Get the whole file as a programming convenience in order to avoid
77
* malloc+lseek+read+free of many pieces. If successful, then mmap
78
* avoids copying unused pieces; else just read the whole file.
79
* Open for both read and write.
81
static void *mmap_file(char const *fname)
85
fd_map = open(fname, O_RDWR);
86
if (fd_map < 0 || fstat(fd_map, &sb) < 0) {
90
if (!S_ISREG(sb.st_mode)) {
91
fprintf(stderr, "not a regular file: %s\n", fname);
94
addr = mmap(0, sb.st_size, PROT_READ|PROT_WRITE, MAP_SHARED,
96
if (addr == MAP_FAILED) {
98
fprintf(stderr, "Could not mmap file: %s\n", fname);
104
static uint64_t r8be(const uint64_t *x)
106
return get_unaligned_be64(x);
108
static uint32_t rbe(const uint32_t *x)
110
return get_unaligned_be32(x);
112
static uint16_t r2be(const uint16_t *x)
114
return get_unaligned_be16(x);
116
static uint64_t r8le(const uint64_t *x)
118
return get_unaligned_le64(x);
120
static uint32_t rle(const uint32_t *x)
122
return get_unaligned_le32(x);
124
static uint16_t r2le(const uint16_t *x)
126
return get_unaligned_le16(x);
129
static void w8be(uint64_t val, uint64_t *x)
131
put_unaligned_be64(val, x);
133
static void wbe(uint32_t val, uint32_t *x)
135
put_unaligned_be32(val, x);
137
static void w2be(uint16_t val, uint16_t *x)
139
put_unaligned_be16(val, x);
141
static void w8le(uint64_t val, uint64_t *x)
143
put_unaligned_le64(val, x);
145
static void wle(uint32_t val, uint32_t *x)
147
put_unaligned_le32(val, x);
149
static void w2le(uint16_t val, uint16_t *x)
151
put_unaligned_le16(val, x);
154
static uint64_t (*r8)(const uint64_t *);
155
static uint32_t (*r)(const uint32_t *);
156
static uint16_t (*r2)(const uint16_t *);
157
static void (*w8)(uint64_t, uint64_t *);
158
static void (*w)(uint32_t, uint32_t *);
159
static void (*w2)(uint16_t, uint16_t *);
161
typedef void (*table_sort_t)(char *, int);
163
/* 32 bit and 64 bit are very similar */
164
#include "sortextable.h"
165
#define SORTEXTABLE_64
166
#include "sortextable.h"
168
static int compare_relative_table(const void *a, const void *b)
170
int32_t av = (int32_t)r(a);
171
int32_t bv = (int32_t)r(b);
180
static void sort_relative_table(char *extab_image, int image_size)
185
* Do the same thing the runtime sort does, first normalize to
186
* being relative to the start of the section.
189
while (i < image_size) {
190
uint32_t *loc = (uint32_t *)(extab_image + i);
195
qsort(extab_image, image_size / 8, 8, compare_relative_table);
197
/* Now denormalize. */
199
while (i < image_size) {
200
uint32_t *loc = (uint32_t *)(extab_image + i);
207
do_file(char const *const fname)
209
table_sort_t custom_sort;
210
Elf32_Ehdr *ehdr = mmap_file(fname);
213
switch (ehdr->e_ident[EI_DATA]) {
215
fprintf(stderr, "unrecognized ELF data encoding %d: %s\n",
216
ehdr->e_ident[EI_DATA], fname);
236
if (memcmp(ELFMAG, ehdr->e_ident, SELFMAG) != 0
237
|| r2(&ehdr->e_type) != ET_EXEC
238
|| ehdr->e_ident[EI_VERSION] != EV_CURRENT) {
239
fprintf(stderr, "unrecognized ET_EXEC file %s\n", fname);
244
switch (r2(&ehdr->e_machine)) {
246
fprintf(stderr, "unrecognized e_machine %d %s\n",
247
r2(&ehdr->e_machine), fname);
253
custom_sort = sort_relative_table;
261
switch (ehdr->e_ident[EI_CLASS]) {
263
fprintf(stderr, "unrecognized ELF class %d %s\n",
264
ehdr->e_ident[EI_CLASS], fname);
268
if (r2(&ehdr->e_ehsize) != sizeof(Elf32_Ehdr)
269
|| r2(&ehdr->e_shentsize) != sizeof(Elf32_Shdr)) {
271
"unrecognized ET_EXEC file: %s\n", fname);
274
do32(ehdr, fname, custom_sort);
277
Elf64_Ehdr *const ghdr = (Elf64_Ehdr *)ehdr;
278
if (r2(&ghdr->e_ehsize) != sizeof(Elf64_Ehdr)
279
|| r2(&ghdr->e_shentsize) != sizeof(Elf64_Shdr)) {
281
"unrecognized ET_EXEC file: %s\n", fname);
284
do64(ghdr, fname, custom_sort);
293
main(int argc, char *argv[])
295
int n_error = 0; /* gcc-4.3.0 false positive complaint */
299
fprintf(stderr, "usage: sortextable vmlinux...\n");
303
/* Process each file in turn, allowing deep failure. */
304
for (i = 1; i < argc; i++) {
305
char *file = argv[i];
306
int const sjval = setjmp(jmpenv);
310
fprintf(stderr, "internal error: %s\n", file);
313
case SJ_SETJMP: /* normal sequence */
314
/* Avoid problems if early cleanup() */
320
case SJ_FAIL: /* error in do_file or below */
323
case SJ_SUCCEED: /* premature success */