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 <shile.zhang@linux.alibaba.com> |
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 <jreiser@BitWagon.com>. All rights reserved. |
14 | * |
15 | * Restructured to fit Linux format, as well as other updates: |
16 | * Copyright 2010 Steven Rostedt <srostedt@redhat.com>, 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 | |
63 | #ifndef EM_LOONGARCH |
64 | #define EM_LOONGARCH 258 |
65 | #endif |
66 | |
67 | static uint32_t (*r)(const uint32_t *); |
68 | static uint16_t (*r2)(const uint16_t *); |
69 | static uint64_t (*r8)(const uint64_t *); |
70 | static void (*w)(uint32_t, uint32_t *); |
71 | static void (*w2)(uint16_t, uint16_t *); |
72 | static void (*w8)(uint64_t, uint64_t *); |
73 | typedef void (*table_sort_t)(char *, int); |
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 | */ |
81 | static void *mmap_file(char const *fname, size_t *size) |
82 | { |
83 | int fd; |
84 | struct stat sb; |
85 | void *addr = NULL; |
86 | |
87 | fd = open(file: fname, O_RDWR); |
88 | if (fd < 0) { |
89 | perror(s: fname); |
90 | return NULL; |
91 | } |
92 | if (fstat(fd: fd, buf: &sb) < 0) { |
93 | perror(s: fname); |
94 | goto out; |
95 | } |
96 | if (!S_ISREG(sb.st_mode)) { |
97 | fprintf(stderr, format: "not a regular file: %s\n" , fname); |
98 | goto out; |
99 | } |
100 | |
101 | addr = mmap(addr: 0, len: sb.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd: fd, offset: 0); |
102 | if (addr == MAP_FAILED) { |
103 | fprintf(stderr, format: "Could not mmap file: %s\n" , fname); |
104 | goto out; |
105 | } |
106 | |
107 | *size = sb.st_size; |
108 | |
109 | out: |
110 | close(fd: fd); |
111 | return addr; |
112 | } |
113 | |
114 | static uint32_t rbe(const uint32_t *x) |
115 | { |
116 | return get_unaligned_be32(x); |
117 | } |
118 | |
119 | static uint16_t r2be(const uint16_t *x) |
120 | { |
121 | return get_unaligned_be16(x); |
122 | } |
123 | |
124 | static uint64_t r8be(const uint64_t *x) |
125 | { |
126 | return get_unaligned_be64(x); |
127 | } |
128 | |
129 | static uint32_t rle(const uint32_t *x) |
130 | { |
131 | return get_unaligned_le32(x); |
132 | } |
133 | |
134 | static uint16_t r2le(const uint16_t *x) |
135 | { |
136 | return get_unaligned_le16(x); |
137 | } |
138 | |
139 | static uint64_t r8le(const uint64_t *x) |
140 | { |
141 | return get_unaligned_le64(x); |
142 | } |
143 | |
144 | static void wbe(uint32_t val, uint32_t *x) |
145 | { |
146 | put_unaligned_be32(val, x); |
147 | } |
148 | |
149 | static void w2be(uint16_t val, uint16_t *x) |
150 | { |
151 | put_unaligned_be16(val, x); |
152 | } |
153 | |
154 | static void w8be(uint64_t val, uint64_t *x) |
155 | { |
156 | put_unaligned_be64(val, x); |
157 | } |
158 | |
159 | static void wle(uint32_t val, uint32_t *x) |
160 | { |
161 | put_unaligned_le32(val, x); |
162 | } |
163 | |
164 | static void w2le(uint16_t val, uint16_t *x) |
165 | { |
166 | put_unaligned_le16(val, x); |
167 | } |
168 | |
169 | static void w8le(uint64_t val, uint64_t *x) |
170 | { |
171 | put_unaligned_le64(val, x); |
172 | } |
173 | |
174 | /* |
175 | * Move reserved section indices SHN_LORESERVE..SHN_HIRESERVE out of |
176 | * the way to -256..-1, to avoid conflicting with real section |
177 | * indices. |
178 | */ |
179 | #define SPECIAL(i) ((i) - (SHN_HIRESERVE + 1)) |
180 | |
181 | static inline int is_shndx_special(unsigned int i) |
182 | { |
183 | return i != SHN_XINDEX && i >= SHN_LORESERVE && i <= SHN_HIRESERVE; |
184 | } |
185 | |
186 | /* Accessor for sym->st_shndx, hides ugliness of "64k sections" */ |
187 | static inline unsigned int get_secindex(unsigned int shndx, |
188 | unsigned int sym_offs, |
189 | const Elf32_Word *symtab_shndx_start) |
190 | { |
191 | if (is_shndx_special(i: shndx)) |
192 | return SPECIAL(shndx); |
193 | if (shndx != SHN_XINDEX) |
194 | return shndx; |
195 | return r(&symtab_shndx_start[sym_offs]); |
196 | } |
197 | |
198 | /* 32 bit and 64 bit are very similar */ |
199 | #include "sorttable.h" |
200 | #define SORTTABLE_64 |
201 | #include "sorttable.h" |
202 | |
203 | static int compare_relative_table(const void *a, const void *b) |
204 | { |
205 | int32_t av = (int32_t)r(a); |
206 | int32_t bv = (int32_t)r(b); |
207 | |
208 | if (av < bv) |
209 | return -1; |
210 | if (av > bv) |
211 | return 1; |
212 | return 0; |
213 | } |
214 | |
215 | static void sort_relative_table(char *extab_image, int image_size) |
216 | { |
217 | int i = 0; |
218 | |
219 | /* |
220 | * Do the same thing the runtime sort does, first normalize to |
221 | * being relative to the start of the section. |
222 | */ |
223 | while (i < image_size) { |
224 | uint32_t *loc = (uint32_t *)(extab_image + i); |
225 | w(r(loc) + i, loc); |
226 | i += 4; |
227 | } |
228 | |
229 | qsort(base: extab_image, nmemb: image_size / 8, size: 8, compar: compare_relative_table); |
230 | |
231 | /* Now denormalize. */ |
232 | i = 0; |
233 | while (i < image_size) { |
234 | uint32_t *loc = (uint32_t *)(extab_image + i); |
235 | w(r(loc) - i, loc); |
236 | i += 4; |
237 | } |
238 | } |
239 | |
240 | static void sort_relative_table_with_data(char *extab_image, int image_size) |
241 | { |
242 | int i = 0; |
243 | |
244 | while (i < image_size) { |
245 | uint32_t *loc = (uint32_t *)(extab_image + i); |
246 | |
247 | w(r(loc) + i, loc); |
248 | w(r(loc + 1) + i + 4, loc + 1); |
249 | /* Don't touch the fixup type or data */ |
250 | |
251 | i += sizeof(uint32_t) * 3; |
252 | } |
253 | |
254 | qsort(base: extab_image, nmemb: image_size / 12, size: 12, compar: compare_relative_table); |
255 | |
256 | i = 0; |
257 | while (i < image_size) { |
258 | uint32_t *loc = (uint32_t *)(extab_image + i); |
259 | |
260 | w(r(loc) - i, loc); |
261 | w(r(loc + 1) - (i + 4), loc + 1); |
262 | /* Don't touch the fixup type or data */ |
263 | |
264 | i += sizeof(uint32_t) * 3; |
265 | } |
266 | } |
267 | |
268 | static int do_file(char const *const fname, void *addr) |
269 | { |
270 | int rc = -1; |
271 | Elf32_Ehdr *ehdr = addr; |
272 | table_sort_t custom_sort = NULL; |
273 | |
274 | switch (ehdr->e_ident[EI_DATA]) { |
275 | case ELFDATA2LSB: |
276 | r = rle; |
277 | r2 = r2le; |
278 | r8 = r8le; |
279 | w = wle; |
280 | w2 = w2le; |
281 | w8 = w8le; |
282 | break; |
283 | case ELFDATA2MSB: |
284 | r = rbe; |
285 | r2 = r2be; |
286 | r8 = r8be; |
287 | w = wbe; |
288 | w2 = w2be; |
289 | w8 = w8be; |
290 | break; |
291 | default: |
292 | fprintf(stderr, format: "unrecognized ELF data encoding %d: %s\n" , |
293 | ehdr->e_ident[EI_DATA], fname); |
294 | return -1; |
295 | } |
296 | |
297 | if (memcmp(ELFMAG, s2: 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, format: "unrecognized ET_EXEC/ET_DYN file %s\n" , fname); |
301 | return -1; |
302 | } |
303 | |
304 | switch (r2(&ehdr->e_machine)) { |
305 | case EM_386: |
306 | case EM_AARCH64: |
307 | case EM_LOONGARCH: |
308 | case EM_RISCV: |
309 | case EM_S390: |
310 | case EM_X86_64: |
311 | custom_sort = sort_relative_table_with_data; |
312 | break; |
313 | case EM_PARISC: |
314 | case EM_PPC: |
315 | case EM_PPC64: |
316 | custom_sort = sort_relative_table; |
317 | break; |
318 | case EM_ARCOMPACT: |
319 | case EM_ARCV2: |
320 | case EM_ARM: |
321 | case EM_MICROBLAZE: |
322 | case EM_MIPS: |
323 | case EM_XTENSA: |
324 | break; |
325 | default: |
326 | fprintf(stderr, format: "unrecognized e_machine %d %s\n" , |
327 | r2(&ehdr->e_machine), fname); |
328 | return -1; |
329 | } |
330 | |
331 | switch (ehdr->e_ident[EI_CLASS]) { |
332 | case ELFCLASS32: |
333 | if (r2(&ehdr->e_ehsize) != sizeof(Elf32_Ehdr) || |
334 | r2(&ehdr->e_shentsize) != sizeof(Elf32_Shdr)) { |
335 | fprintf(stderr, |
336 | format: "unrecognized ET_EXEC/ET_DYN file: %s\n" , fname); |
337 | break; |
338 | } |
339 | rc = do_sort_32(ehdr, fname, custom_sort); |
340 | break; |
341 | case ELFCLASS64: |
342 | { |
343 | Elf64_Ehdr *const ghdr = (Elf64_Ehdr *)ehdr; |
344 | if (r2(&ghdr->e_ehsize) != sizeof(Elf64_Ehdr) || |
345 | r2(&ghdr->e_shentsize) != sizeof(Elf64_Shdr)) { |
346 | fprintf(stderr, |
347 | format: "unrecognized ET_EXEC/ET_DYN file: %s\n" , |
348 | fname); |
349 | break; |
350 | } |
351 | rc = do_sort_64(ehdr: ghdr, fname, custom_sort); |
352 | } |
353 | break; |
354 | default: |
355 | fprintf(stderr, format: "unrecognized ELF class %d %s\n" , |
356 | ehdr->e_ident[EI_CLASS], fname); |
357 | break; |
358 | } |
359 | |
360 | return rc; |
361 | } |
362 | |
363 | int main(int argc, char *argv[]) |
364 | { |
365 | int i, n_error = 0; /* gcc-4.3.0 false positive complaint */ |
366 | size_t size = 0; |
367 | void *addr = NULL; |
368 | |
369 | if (argc < 2) { |
370 | fprintf(stderr, format: "usage: sorttable vmlinux...\n" ); |
371 | return 0; |
372 | } |
373 | |
374 | /* Process each file in turn, allowing deep failure. */ |
375 | for (i = 1; i < argc; i++) { |
376 | addr = mmap_file(fname: argv[i], size: &size); |
377 | if (!addr) { |
378 | ++n_error; |
379 | continue; |
380 | } |
381 | |
382 | if (do_file(fname: argv[i], addr)) |
383 | ++n_error; |
384 | |
385 | munmap(addr: addr, len: size); |
386 | } |
387 | |
388 | return !!n_error; |
389 | } |
390 | |