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