Root/scripts/sortextable.c

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
38static 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
67static void __attribute__((noreturn))
68succeed_file(void)
69{
70    cleanup();
71    longjmp(jmpenv, SJ_SUCCEED);
72}
73
74
75/*
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.
80 */
81static void *mmap_file(char const *fname)
82{
83    void *addr;
84
85    fd_map = open(fname, O_RDWR);
86    if (fd_map < 0 || fstat(fd_map, &sb) < 0) {
87        perror(fname);
88        fail_file();
89    }
90    if (!S_ISREG(sb.st_mode)) {
91        fprintf(stderr, "not a regular file: %s\n", fname);
92        fail_file();
93    }
94    addr = mmap(0, sb.st_size, PROT_READ|PROT_WRITE, MAP_SHARED,
95            fd_map, 0);
96    if (addr == MAP_FAILED) {
97        mmap_failed = 1;
98        fprintf(stderr, "Could not mmap file: %s\n", fname);
99        fail_file();
100    }
101    return addr;
102}
103
104static uint64_t r8be(const uint64_t *x)
105{
106    return get_unaligned_be64(x);
107}
108static uint32_t rbe(const uint32_t *x)
109{
110    return get_unaligned_be32(x);
111}
112static uint16_t r2be(const uint16_t *x)
113{
114    return get_unaligned_be16(x);
115}
116static uint64_t r8le(const uint64_t *x)
117{
118    return get_unaligned_le64(x);
119}
120static uint32_t rle(const uint32_t *x)
121{
122    return get_unaligned_le32(x);
123}
124static uint16_t r2le(const uint16_t *x)
125{
126    return get_unaligned_le16(x);
127}
128
129static void w8be(uint64_t val, uint64_t *x)
130{
131    put_unaligned_be64(val, x);
132}
133static void wbe(uint32_t val, uint32_t *x)
134{
135    put_unaligned_be32(val, x);
136}
137static void w2be(uint16_t val, uint16_t *x)
138{
139    put_unaligned_be16(val, x);
140}
141static void w8le(uint64_t val, uint64_t *x)
142{
143    put_unaligned_le64(val, x);
144}
145static void wle(uint32_t val, uint32_t *x)
146{
147    put_unaligned_le32(val, x);
148}
149static void w2le(uint16_t val, uint16_t *x)
150{
151    put_unaligned_le16(val, x);
152}
153
154static uint64_t (*r8)(const uint64_t *);
155static uint32_t (*r)(const uint32_t *);
156static uint16_t (*r2)(const uint16_t *);
157static void (*w8)(uint64_t, uint64_t *);
158static void (*w)(uint32_t, uint32_t *);
159static void (*w2)(uint16_t, uint16_t *);
160
161typedef void (*table_sort_t)(char *, int);
162
163/* 32 bit and 64 bit are very similar */
164#include "sortextable.h"
165#define SORTEXTABLE_64
166#include "sortextable.h"
167
168static int compare_relative_table(const void *a, const void *b)
169{
170    int32_t av = (int32_t)r(a);
171    int32_t bv = (int32_t)r(b);
172
173    if (av < bv)
174        return -1;
175    if (av > bv)
176        return 1;
177    return 0;
178}
179
180static void sort_relative_table(char *extab_image, int image_size)
181{
182    int i;
183
184    /*
185     * Do the same thing the runtime sort does, first normalize to
186     * being relative to the start of the section.
187     */
188    i = 0;
189    while (i < image_size) {
190        uint32_t *loc = (uint32_t *)(extab_image + i);
191        w(r(loc) + i, loc);
192        i += 4;
193    }
194
195    qsort(extab_image, image_size / 8, 8, compare_relative_table);
196
197    /* Now denormalize. */
198    i = 0;
199    while (i < image_size) {
200        uint32_t *loc = (uint32_t *)(extab_image + i);
201        w(r(loc) - i, loc);
202        i += 4;
203    }
204}
205
206static void
207do_file(char const *const fname)
208{
209    table_sort_t custom_sort;
210    Elf32_Ehdr *ehdr = mmap_file(fname);
211
212    ehdr_curr = ehdr;
213    switch (ehdr->e_ident[EI_DATA]) {
214    default:
215        fprintf(stderr, "unrecognized ELF data encoding %d: %s\n",
216            ehdr->e_ident[EI_DATA], fname);
217        fail_file();
218        break;
219    case ELFDATA2LSB:
220        r = rle;
221        r2 = r2le;
222        r8 = r8le;
223        w = wle;
224        w2 = w2le;
225        w8 = w8le;
226        break;
227    case ELFDATA2MSB:
228        r = rbe;
229        r2 = r2be;
230        r8 = r8be;
231        w = wbe;
232        w2 = w2be;
233        w8 = w8be;
234        break;
235    } /* end switch */
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);
240        fail_file();
241    }
242
243    custom_sort = NULL;
244    switch (r2(&ehdr->e_machine)) {
245    default:
246        fprintf(stderr, "unrecognized e_machine %d %s\n",
247            r2(&ehdr->e_machine), fname);
248        fail_file();
249        break;
250    case EM_386:
251    case EM_X86_64:
252    case EM_S390:
253        custom_sort = sort_relative_table;
254        break;
255    case EM_ARM:
256    case EM_AARCH64:
257    case EM_MIPS:
258        break;
259    } /* end switch */
260
261    switch (ehdr->e_ident[EI_CLASS]) {
262    default:
263        fprintf(stderr, "unrecognized ELF class %d %s\n",
264            ehdr->e_ident[EI_CLASS], fname);
265        fail_file();
266        break;
267    case ELFCLASS32:
268        if (r2(&ehdr->e_ehsize) != sizeof(Elf32_Ehdr)
269        || r2(&ehdr->e_shentsize) != sizeof(Elf32_Shdr)) {
270            fprintf(stderr,
271                "unrecognized ET_EXEC file: %s\n", fname);
272            fail_file();
273        }
274        do32(ehdr, fname, custom_sort);
275        break;
276    case ELFCLASS64: {
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)) {
280            fprintf(stderr,
281                "unrecognized ET_EXEC file: %s\n", fname);
282            fail_file();
283        }
284        do64(ghdr, fname, custom_sort);
285        break;
286    }
287    } /* end switch */
288
289    cleanup();
290}
291
292int
293main(int argc, char *argv[])
294{
295    int n_error = 0; /* gcc-4.3.0 false positive complaint */
296    int i;
297
298    if (argc < 2) {
299        fprintf(stderr, "usage: sortextable vmlinux...\n");
300        return 0;
301    }
302
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);
307
308        switch (sjval) {
309        default:
310            fprintf(stderr, "internal error: %s\n", file);
311            exit(1);
312            break;
313        case SJ_SETJMP: /* normal sequence */
314            /* Avoid problems if early cleanup() */
315            fd_map = -1;
316            ehdr_curr = NULL;
317            mmap_failed = 1;
318            do_file(file);
319            break;
320        case SJ_FAIL: /* error in do_file or below */
321            ++n_error;
322            break;
323        case SJ_SUCCEED: /* premature success */
324            /* do nothing */
325            break;
326        } /* end switch */
327    }
328    return !!n_error;
329}
330

Archive Download this file



interactive