David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 1 | /* |
| 2 | * sortextable.c: Sort the kernel's exception table |
| 3 | * |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 4 | * Copyright 2011 - 2012 Cavium, Inc. |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 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 | |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 31 | #include <tools/be_byteshift.h> |
| 32 | #include <tools/le_byteshift.h> |
| 33 | |
Vineet Gupta | f06d19e | 2013-11-15 12:08:05 +0530 | [diff] [blame] | 34 | #ifndef EM_ARCOMPACT |
| 35 | #define EM_ARCOMPACT 93 |
| 36 | #endif |
| 37 | |
Max Filippov | 25df819 | 2014-02-18 15:29:11 +0400 | [diff] [blame] | 38 | #ifndef EM_XTENSA |
| 39 | #define EM_XTENSA 94 |
| 40 | #endif |
| 41 | |
Will Deacon | adace89 | 2013-05-08 17:29:24 +0100 | [diff] [blame] | 42 | #ifndef EM_AARCH64 |
| 43 | #define EM_AARCH64 183 |
| 44 | #endif |
| 45 | |
Michal Simek | 372c720 | 2014-01-23 15:52:46 -0800 | [diff] [blame] | 46 | #ifndef EM_MICROBLAZE |
| 47 | #define EM_MICROBLAZE 189 |
| 48 | #endif |
| 49 | |
Vineet Gupta | b3210d1 | 2013-11-22 13:05:58 +0530 | [diff] [blame] | 50 | #ifndef EM_ARCV2 |
| 51 | #define EM_ARCV2 195 |
| 52 | #endif |
| 53 | |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 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 | |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 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 | |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 112 | static uint64_t r8be(const uint64_t *x) |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 113 | { |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 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); |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 135 | } |
| 136 | |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 137 | static void w8be(uint64_t val, uint64_t *x) |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 138 | { |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 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); |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 160 | } |
| 161 | |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 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 *); |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 168 | |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 169 | typedef void (*table_sort_t)(char *, int); |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 170 | |
Jamie Iles | 59c3645 | 2013-11-12 15:06:51 -0800 | [diff] [blame] | 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 | |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 195 | /* 32 bit and 64 bit are very similar */ |
| 196 | #include "sortextable.h" |
| 197 | #define SORTEXTABLE_64 |
| 198 | #include "sortextable.h" |
| 199 | |
Heiko Carstens | eb608fb | 2012-09-05 13:26:11 +0200 | [diff] [blame] | 200 | static int compare_relative_table(const void *a, const void *b) |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 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 | |
Tony Luck | 548acf1 | 2016-02-17 10:20:12 -0800 | [diff] [blame] | 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 | |
Heiko Carstens | eb608fb | 2012-09-05 13:26:11 +0200 | [diff] [blame] | 241 | static void sort_relative_table(char *extab_image, int image_size) |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 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 | |
Heiko Carstens | eb608fb | 2012-09-05 13:26:11 +0200 | [diff] [blame] | 256 | qsort(extab_image, image_size / 8, 8, compare_relative_table); |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 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 | } |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 266 | |
| 267 | static void |
| 268 | do_file(char const *const fname) |
| 269 | { |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 270 | table_sort_t custom_sort; |
| 271 | Elf32_Ehdr *ehdr = mmap_file(fname); |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 272 | |
| 273 | ehdr_curr = ehdr; |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 274 | switch (ehdr->e_ident[EI_DATA]) { |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 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: |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 281 | r = rle; |
| 282 | r2 = r2le; |
| 283 | r8 = r8le; |
| 284 | w = wle; |
| 285 | w2 = w2le; |
| 286 | w8 = w8le; |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 287 | break; |
| 288 | case ELFDATA2MSB: |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 289 | r = rbe; |
| 290 | r2 = r2be; |
| 291 | r8 = r8be; |
| 292 | w = wbe; |
| 293 | w2 = w2be; |
| 294 | w8 = w8be; |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 295 | break; |
| 296 | } /* end switch */ |
| 297 | if (memcmp(ELFMAG, ehdr->e_ident, SELFMAG) != 0 |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 298 | || r2(&ehdr->e_type) != ET_EXEC |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 299 | || ehdr->e_ident[EI_VERSION] != EV_CURRENT) { |
| 300 | fprintf(stderr, "unrecognized ET_EXEC file %s\n", fname); |
| 301 | fail_file(); |
| 302 | } |
| 303 | |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 304 | custom_sort = NULL; |
| 305 | switch (r2(&ehdr->e_machine)) { |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 306 | default: |
| 307 | fprintf(stderr, "unrecognized e_machine %d %s\n", |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 308 | r2(&ehdr->e_machine), fname); |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 309 | fail_file(); |
| 310 | break; |
| 311 | case EM_386: |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 312 | case EM_X86_64: |
Tony Luck | 548acf1 | 2016-02-17 10:20:12 -0800 | [diff] [blame] | 313 | custom_sort = x86_sort_relative_table; |
| 314 | break; |
| 315 | |
Heiko Carstens | 3193a98 | 2012-07-24 14:51:34 +0200 | [diff] [blame] | 316 | case EM_S390: |
Heiko Carstens | eb608fb | 2012-09-05 13:26:11 +0200 | [diff] [blame] | 317 | custom_sort = sort_relative_table; |
| 318 | break; |
Vineet Gupta | f06d19e | 2013-11-15 12:08:05 +0530 | [diff] [blame] | 319 | case EM_ARCOMPACT: |
Vineet Gupta | b3210d1 | 2013-11-22 13:05:58 +0530 | [diff] [blame] | 320 | case EM_ARCV2: |
Stephen Boyd | ee951c6 | 2012-10-29 19:19:34 +0100 | [diff] [blame] | 321 | case EM_ARM: |
Will Deacon | adace89 | 2013-05-08 17:29:24 +0100 | [diff] [blame] | 322 | case EM_AARCH64: |
Michal Simek | 372c720 | 2014-01-23 15:52:46 -0800 | [diff] [blame] | 323 | case EM_MICROBLAZE: |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 324 | case EM_MIPS: |
Max Filippov | 25df819 | 2014-02-18 15:29:11 +0400 | [diff] [blame] | 325 | case EM_XTENSA: |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 326 | break; |
| 327 | } /* end switch */ |
| 328 | |
| 329 | switch (ehdr->e_ident[EI_CLASS]) { |
| 330 | default: |
| 331 | fprintf(stderr, "unrecognized ELF class %d %s\n", |
| 332 | ehdr->e_ident[EI_CLASS], fname); |
| 333 | fail_file(); |
| 334 | break; |
| 335 | case ELFCLASS32: |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 336 | if (r2(&ehdr->e_ehsize) != sizeof(Elf32_Ehdr) |
| 337 | || r2(&ehdr->e_shentsize) != sizeof(Elf32_Shdr)) { |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 338 | fprintf(stderr, |
| 339 | "unrecognized ET_EXEC file: %s\n", fname); |
| 340 | fail_file(); |
| 341 | } |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 342 | do32(ehdr, fname, custom_sort); |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 343 | break; |
| 344 | case ELFCLASS64: { |
| 345 | Elf64_Ehdr *const ghdr = (Elf64_Ehdr *)ehdr; |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 346 | if (r2(&ghdr->e_ehsize) != sizeof(Elf64_Ehdr) |
| 347 | || r2(&ghdr->e_shentsize) != sizeof(Elf64_Shdr)) { |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 348 | fprintf(stderr, |
| 349 | "unrecognized ET_EXEC file: %s\n", fname); |
| 350 | fail_file(); |
| 351 | } |
David Daney | d59a168 | 2012-04-24 11:23:14 -0700 | [diff] [blame] | 352 | do64(ghdr, fname, custom_sort); |
David Daney | a79f248 | 2012-04-19 14:59:55 -0700 | [diff] [blame] | 353 | break; |
| 354 | } |
| 355 | } /* end switch */ |
| 356 | |
| 357 | cleanup(); |
| 358 | } |
| 359 | |
| 360 | int |
| 361 | main(int argc, char *argv[]) |
| 362 | { |
| 363 | int n_error = 0; /* gcc-4.3.0 false positive complaint */ |
| 364 | int i; |
| 365 | |
| 366 | if (argc < 2) { |
| 367 | fprintf(stderr, "usage: sortextable vmlinux...\n"); |
| 368 | return 0; |
| 369 | } |
| 370 | |
| 371 | /* Process each file in turn, allowing deep failure. */ |
| 372 | for (i = 1; i < argc; i++) { |
| 373 | char *file = argv[i]; |
| 374 | int const sjval = setjmp(jmpenv); |
| 375 | |
| 376 | switch (sjval) { |
| 377 | default: |
| 378 | fprintf(stderr, "internal error: %s\n", file); |
| 379 | exit(1); |
| 380 | break; |
| 381 | case SJ_SETJMP: /* normal sequence */ |
| 382 | /* Avoid problems if early cleanup() */ |
| 383 | fd_map = -1; |
| 384 | ehdr_curr = NULL; |
| 385 | mmap_failed = 1; |
| 386 | do_file(file); |
| 387 | break; |
| 388 | case SJ_FAIL: /* error in do_file or below */ |
| 389 | ++n_error; |
| 390 | break; |
| 391 | case SJ_SUCCEED: /* premature success */ |
| 392 | /* do nothing */ |
| 393 | break; |
| 394 | } /* end switch */ |
| 395 | } |
| 396 | return !!n_error; |
| 397 | } |