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_ARCOMPACT
 35#define EM_ARCOMPACT	93
 36#endif
 37
 38#ifndef EM_XTENSA
 39#define EM_XTENSA	94
 40#endif
 41
 42#ifndef EM_AARCH64
 43#define EM_AARCH64	183
 44#endif
 45
 46#ifndef EM_MICROBLAZE
 47#define EM_MICROBLAZE	189
 48#endif
 49
 50#ifndef EM_ARCV2
 51#define EM_ARCV2	195
 52#endif
 53
 54static int fd_map;	/* File descriptor for file being modified. */
 55static int mmap_failed; /* Boolean flag. */
 56static void *ehdr_curr; /* current ElfXX_Ehdr *  for resource cleanup */
 57static struct stat sb;	/* Remember .st_size, etc. */
 58static jmp_buf jmpenv;	/* setjmp/longjmp per-file error escape */
 59
 60/* setjmp() return values */
 61enum {
 62	SJ_SETJMP = 0,  /* hardwired first return */
 63	SJ_FAIL,
 64	SJ_SUCCEED
 65};
 66
 67/* Per-file resource cleanup when multiple files. */
 68static void
 69cleanup(void)
 70{
 71	if (!mmap_failed)
 72		munmap(ehdr_curr, sb.st_size);
 73	close(fd_map);
 74}
 75
 76static void __attribute__((noreturn))
 77fail_file(void)
 78{
 79	cleanup();
 80	longjmp(jmpenv, SJ_FAIL);
 81}
 82
 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 */
 89static 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
112static uint64_t r8be(const uint64_t *x)
113{
114	return get_unaligned_be64(x);
115}
116static uint32_t rbe(const uint32_t *x)
117{
118	return get_unaligned_be32(x);
119}
120static uint16_t r2be(const uint16_t *x)
121{
122	return get_unaligned_be16(x);
123}
124static uint64_t r8le(const uint64_t *x)
125{
126	return get_unaligned_le64(x);
127}
128static uint32_t rle(const uint32_t *x)
129{
130	return get_unaligned_le32(x);
131}
132static uint16_t r2le(const uint16_t *x)
133{
134	return get_unaligned_le16(x);
135}
136
137static void w8be(uint64_t val, uint64_t *x)
138{
139	put_unaligned_be64(val, x);
140}
141static void wbe(uint32_t val, uint32_t *x)
142{
143	put_unaligned_be32(val, x);
144}
145static void w2be(uint16_t val, uint16_t *x)
146{
147	put_unaligned_be16(val, x);
148}
149static void w8le(uint64_t val, uint64_t *x)
150{
151	put_unaligned_le64(val, x);
152}
153static void wle(uint32_t val, uint32_t *x)
154{
155	put_unaligned_le32(val, x);
156}
157static void w2le(uint16_t val, uint16_t *x)
158{
159	put_unaligned_le16(val, x);
160}
161
162static uint64_t (*r8)(const uint64_t *);
163static uint32_t (*r)(const uint32_t *);
164static uint16_t (*r2)(const uint16_t *);
165static void (*w8)(uint64_t, uint64_t *);
166static void (*w)(uint32_t, uint32_t *);
167static void (*w2)(uint16_t, uint16_t *);
168
169typedef void (*table_sort_t)(char *, int);
170
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
178static 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" */
184static 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
195/* 32 bit and 64 bit are very similar */
196#include "sortextable.h"
197#define SORTEXTABLE_64
198#include "sortextable.h"
199
200static int compare_relative_table(const void *a, const void *b)
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
212static 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
241static void sort_relative_table(char *extab_image, int image_size)
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
256	qsort(extab_image, image_size / 8, 8, compare_relative_table);
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}
266
267static void
268do_file(char const *const fname)
269{
270	table_sort_t custom_sort;
271	Elf32_Ehdr *ehdr = mmap_file(fname);
272
273	ehdr_curr = ehdr;
274	switch (ehdr->e_ident[EI_DATA]) {
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:
281		r = rle;
282		r2 = r2le;
283		r8 = r8le;
284		w = wle;
285		w2 = w2le;
286		w8 = w8le;
287		break;
288	case ELFDATA2MSB:
289		r = rbe;
290		r2 = r2be;
291		r8 = r8be;
292		w = wbe;
293		w2 = w2be;
294		w8 = w8be;
295		break;
296	}  /* end switch */
297	if (memcmp(ELFMAG, ehdr->e_ident, SELFMAG) != 0
298	||  (r2(&ehdr->e_type) != ET_EXEC && r2(&ehdr->e_type) != ET_DYN)
299	||  ehdr->e_ident[EI_VERSION] != EV_CURRENT) {
300		fprintf(stderr, "unrecognized ET_EXEC/ET_DYN file %s\n", fname);
301		fail_file();
302	}
303
304	custom_sort = NULL;
305	switch (r2(&ehdr->e_machine)) {
306	default:
307		fprintf(stderr, "unrecognized e_machine %d %s\n",
308			r2(&ehdr->e_machine), fname);
309		fail_file();
310		break;
311	case EM_386:
312	case EM_X86_64:
313		custom_sort = x86_sort_relative_table;
314		break;
315
316	case EM_S390:
317	case EM_AARCH64:
318	case EM_PARISC:
319	case EM_PPC:
320	case EM_PPC64:
321		custom_sort = sort_relative_table;
322		break;
323	case EM_ARCOMPACT:
324	case EM_ARCV2:
325	case EM_ARM:
326	case EM_MICROBLAZE:
327	case EM_MIPS:
328	case EM_XTENSA:
329		break;
330	}  /* end switch */
331
332	switch (ehdr->e_ident[EI_CLASS]) {
333	default:
334		fprintf(stderr, "unrecognized ELF class %d %s\n",
335			ehdr->e_ident[EI_CLASS], fname);
336		fail_file();
337		break;
338	case ELFCLASS32:
339		if (r2(&ehdr->e_ehsize) != sizeof(Elf32_Ehdr)
340		||  r2(&ehdr->e_shentsize) != sizeof(Elf32_Shdr)) {
341			fprintf(stderr,
342				"unrecognized ET_EXEC/ET_DYN file: %s\n", fname);
343			fail_file();
344		}
345		do32(ehdr, fname, custom_sort);
346		break;
347	case ELFCLASS64: {
348		Elf64_Ehdr *const ghdr = (Elf64_Ehdr *)ehdr;
349		if (r2(&ghdr->e_ehsize) != sizeof(Elf64_Ehdr)
350		||  r2(&ghdr->e_shentsize) != sizeof(Elf64_Shdr)) {
351			fprintf(stderr,
352				"unrecognized ET_EXEC/ET_DYN file: %s\n", fname);
353			fail_file();
354		}
355		do64(ghdr, fname, custom_sort);
356		break;
357	}
358	}  /* end switch */
359
360	cleanup();
361}
362
363int
364main(int argc, char *argv[])
365{
366	int n_error = 0;  /* gcc-4.3.0 false positive complaint */
367	int i;
368
369	if (argc < 2) {
370		fprintf(stderr, "usage: sortextable vmlinux...\n");
371		return 0;
372	}
373
374	/* Process each file in turn, allowing deep failure. */
375	for (i = 1; i < argc; i++) {
376		char *file = argv[i];
377		int const sjval = setjmp(jmpenv);
378
379		switch (sjval) {
380		default:
381			fprintf(stderr, "internal error: %s\n", file);
382			exit(1);
383			break;
384		case SJ_SETJMP:    /* normal sequence */
385			/* Avoid problems if early cleanup() */
386			fd_map = -1;
387			ehdr_curr = NULL;
388			mmap_failed = 1;
389			do_file(file);
390			break;
391		case SJ_FAIL:    /* error in do_file or below */
392			++n_error;
393			break;
394		case SJ_SUCCEED:    /* premature success */
395			/* do nothing */
396			break;
397		}  /* end switch */
398	}
399	return !!n_error;
400}