projects/linux·blob 50c94de6 · refs

384 lines · 7.6 KiB

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