xref: /kernel/linux/linux-5.10/scripts/sorttable.c (revision 8c2ecf20) 
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
34#include <tools/be_byteshift.h>
35#include <tools/le_byteshift.h>
36
37#ifndef EM_ARCOMPACT
38#define EM_ARCOMPACT	93
39#endif
40
41#ifndef EM_XTENSA
42#define EM_XTENSA	94
43#endif
44
45#ifndef EM_AARCH64
46#define EM_AARCH64	183
47#endif
48
49#ifndef EM_MICROBLAZE
50#define EM_MICROBLAZE	189
51#endif
52
53#ifndef EM_ARCV2
54#define EM_ARCV2	195
55#endif
56
57#ifndef EM_LOONGARCH
58#define EM_LOONGARCH	258
59#endif
60
61static uint32_t (*r)(const uint32_t *);
62static uint16_t (*r2)(const uint16_t *);
63static uint64_t (*r8)(const uint64_t *);
64static void (*w)(uint32_t, uint32_t *);
65static void (*w2)(uint16_t, uint16_t *);
66static void (*w8)(uint64_t, uint64_t *);
67typedef void (*table_sort_t)(char *, int);
68
69/*
70 * Get the whole file as a programming convenience in order to avoid
71 * malloc+lseek+read+free of many pieces.  If successful, then mmap
72 * avoids copying unused pieces; else just read the whole file.
73 * Open for both read and write.
74 */
75static void *mmap_file(char const *fname, size_t *size)
76{
77	int fd;
78	struct stat sb;
79	void *addr = NULL;
80
81	fd = open(fname, O_RDWR);
82	if (fd < 0) {
83		perror(fname);
84		return NULL;
85	}
86	if (fstat(fd, &sb) < 0) {
87		perror(fname);
88		goto out;
89	}
90	if (!S_ISREG(sb.st_mode)) {
91		fprintf(stderr, "not a regular file: %s\n", fname);
92		goto out;
93	}
94
95	addr = mmap(0, sb.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
96	if (addr == MAP_FAILED) {
97		fprintf(stderr, "Could not mmap file: %s\n", fname);
98		goto out;
99	}
100
101	*size = sb.st_size;
102
103out:
104	close(fd);
105	return addr;
106}
107
108static uint32_t rbe(const uint32_t *x)
109{
110	return get_unaligned_be32(x);
111}
112
113static uint16_t r2be(const uint16_t *x)
114{
115	return get_unaligned_be16(x);
116}
117
118static uint64_t r8be(const uint64_t *x)
119{
120	return get_unaligned_be64(x);
121}
122
123static uint32_t rle(const uint32_t *x)
124{
125	return get_unaligned_le32(x);
126}
127
128static uint16_t r2le(const uint16_t *x)
129{
130	return get_unaligned_le16(x);
131}
132
133static uint64_t r8le(const uint64_t *x)
134{
135	return get_unaligned_le64(x);
136}
137
138static void wbe(uint32_t val, uint32_t *x)
139{
140	put_unaligned_be32(val, x);
141}
142
143static void w2be(uint16_t val, uint16_t *x)
144{
145	put_unaligned_be16(val, x);
146}
147
148static void w8be(uint64_t val, uint64_t *x)
149{
150	put_unaligned_be64(val, x);
151}
152
153static void wle(uint32_t val, uint32_t *x)
154{
155	put_unaligned_le32(val, x);
156}
157
158static void w2le(uint16_t val, uint16_t *x)
159{
160	put_unaligned_le16(val, x);
161}
162
163static void w8le(uint64_t val, uint64_t *x)
164{
165	put_unaligned_le64(val, x);
166}
167
168/*
169 * Move reserved section indices SHN_LORESERVE..SHN_HIRESERVE out of
170 * the way to -256..-1, to avoid conflicting with real section
171 * indices.
172 */
173#define SPECIAL(i) ((i) - (SHN_HIRESERVE + 1))
174
175static inline int is_shndx_special(unsigned int i)
176{
177	return i != SHN_XINDEX && i >= SHN_LORESERVE && i <= SHN_HIRESERVE;
178}
179
180/* Accessor for sym->st_shndx, hides ugliness of "64k sections" */
181static inline unsigned int get_secindex(unsigned int shndx,
182					unsigned int sym_offs,
183					const Elf32_Word *symtab_shndx_start)
184{
185	if (is_shndx_special(shndx))
186		return SPECIAL(shndx);
187	if (shndx != SHN_XINDEX)
188		return shndx;
189	return r(&symtab_shndx_start[sym_offs]);
190}
191
192/* 32 bit and 64 bit are very similar */
193#include "sorttable.h"
194#define SORTTABLE_64
195#include "sorttable.h"
196
197static int compare_relative_table(const void *a, const void *b)
198{
199	int32_t av = (int32_t)r(a);
200	int32_t bv = (int32_t)r(b);
201
202	if (av < bv)
203		return -1;
204	if (av > bv)
205		return 1;
206	return 0;
207}
208
209static void sort_relative_table(char *extab_image, int image_size)
210{
211	int i = 0;
212
213	/*
214	 * Do the same thing the runtime sort does, first normalize to
215	 * being relative to the start of the section.
216	 */
217	while (i < image_size) {
218		uint32_t *loc = (uint32_t *)(extab_image + i);
219		w(r(loc) + i, loc);
220		i += 4;
221	}
222
223	qsort(extab_image, image_size / 8, 8, compare_relative_table);
224
225	/* Now denormalize. */
226	i = 0;
227	while (i < image_size) {
228		uint32_t *loc = (uint32_t *)(extab_image + i);
229		w(r(loc) - i, loc);
230		i += 4;
231	}
232}
233
234static void sort_relative_table_with_data(char *extab_image, int image_size)
235{
236	int i = 0;
237
238	while (i < image_size) {
239		uint32_t *loc = (uint32_t *)(extab_image + i);
240
241		w(r(loc) + i, loc);
242		w(r(loc + 1) + i + 4, loc + 1);
243		/* Don't touch the fixup type or data */
244
245		i += sizeof(uint32_t) * 3;
246	}
247
248	qsort(extab_image, image_size / 12, 12, compare_relative_table);
249
250	i = 0;
251	while (i < image_size) {
252		uint32_t *loc = (uint32_t *)(extab_image + i);
253
254		w(r(loc) - i, loc);
255		w(r(loc + 1) - (i + 4), loc + 1);
256		/* Don't touch the fixup type or data */
257
258		i += sizeof(uint32_t) * 3;
259	}
260}
261
262static void x86_sort_relative_table(char *extab_image, int image_size)
263{
264	int i = 0;
265
266	while (i < image_size) {
267		uint32_t *loc = (uint32_t *)(extab_image + i);
268
269		w(r(loc) + i, loc);
270		w(r(loc + 1) + i + 4, loc + 1);
271		w(r(loc + 2) + i + 8, loc + 2);
272
273		i += sizeof(uint32_t) * 3;
274	}
275
276	qsort(extab_image, image_size / 12, 12, compare_relative_table);
277
278	i = 0;
279	while (i < image_size) {
280		uint32_t *loc = (uint32_t *)(extab_image + i);
281
282		w(r(loc) - i, loc);
283		w(r(loc + 1) - (i + 4), loc + 1);
284		w(r(loc + 2) - (i + 8), loc + 2);
285
286		i += sizeof(uint32_t) * 3;
287	}
288}
289
290static void s390_sort_relative_table(char *extab_image, int image_size)
291{
292	int i;
293
294	for (i = 0; i < image_size; i += 16) {
295		char *loc = extab_image + i;
296		uint64_t handler;
297
298		w(r((uint32_t *)loc) + i, (uint32_t *)loc);
299		w(r((uint32_t *)(loc + 4)) + (i + 4), (uint32_t *)(loc + 4));
300		/*
301		 * 0 is a special self-relative handler value, which means that
302		 * handler should be ignored. It is safe, because it means that
303		 * handler field points to itself, which should never happen.
304		 * When creating extable-relative values, keep it as 0, since
305		 * this should never occur either: it would mean that handler
306		 * field points to the first extable entry.
307		 */
308		handler = r8((uint64_t *)(loc + 8));
309		if (handler)
310			handler += i + 8;
311		w8(handler, (uint64_t *)(loc + 8));
312	}
313
314	qsort(extab_image, image_size / 16, 16, compare_relative_table);
315
316	for (i = 0; i < image_size; i += 16) {
317		char *loc = extab_image + i;
318		uint64_t handler;
319
320		w(r((uint32_t *)loc) - i, (uint32_t *)loc);
321		w(r((uint32_t *)(loc + 4)) - (i + 4), (uint32_t *)(loc + 4));
322		handler = r8((uint64_t *)(loc + 8));
323		if (handler)
324			handler -= i + 8;
325		w8(handler, (uint64_t *)(loc + 8));
326	}
327}
328
329static int do_file(char const *const fname, void *addr)
330{
331	int rc = -1;
332	Elf32_Ehdr *ehdr = addr;
333	table_sort_t custom_sort = NULL;
334
335	switch (ehdr->e_ident[EI_DATA]) {
336	case ELFDATA2LSB:
337		r	= rle;
338		r2	= r2le;
339		r8	= r8le;
340		w	= wle;
341		w2	= w2le;
342		w8	= w8le;
343		break;
344	case ELFDATA2MSB:
345		r	= rbe;
346		r2	= r2be;
347		r8	= r8be;
348		w	= wbe;
349		w2	= w2be;
350		w8	= w8be;
351		break;
352	default:
353		fprintf(stderr, "unrecognized ELF data encoding %d: %s\n",
354			ehdr->e_ident[EI_DATA], fname);
355		return -1;
356	}
357
358	if (memcmp(ELFMAG, ehdr->e_ident, SELFMAG) != 0 ||
359	    (r2(&ehdr->e_type) != ET_EXEC && r2(&ehdr->e_type) != ET_DYN) ||
360	    ehdr->e_ident[EI_VERSION] != EV_CURRENT) {
361		fprintf(stderr, "unrecognized ET_EXEC/ET_DYN file %s\n", fname);
362		return -1;
363	}
364
365	switch (r2(&ehdr->e_machine)) {
366	case EM_386:
367	case EM_X86_64:
368		custom_sort = x86_sort_relative_table;
369		break;
370	case EM_S390:
371		custom_sort = s390_sort_relative_table;
372		break;
373	case EM_LOONGARCH:
374		custom_sort = sort_relative_table_with_data;
375		break;
376	case EM_AARCH64:
377	case EM_PARISC:
378	case EM_PPC:
379	case EM_ARM:
380	case EM_PPC64:
381		custom_sort = sort_relative_table;
382		break;
383	case EM_ARCOMPACT:
384	case EM_ARCV2:
385	case EM_MICROBLAZE:
386	case EM_MIPS:
387	case EM_XTENSA:
388		break;
389	default:
390		fprintf(stderr, "unrecognized e_machine %d %s\n",
391			r2(&ehdr->e_machine), fname);
392		return -1;
393	}
394
395	switch (ehdr->e_ident[EI_CLASS]) {
396	case ELFCLASS32:
397		if (r2(&ehdr->e_ehsize) != sizeof(Elf32_Ehdr) ||
398		    r2(&ehdr->e_shentsize) != sizeof(Elf32_Shdr)) {
399			fprintf(stderr,
400				"unrecognized ET_EXEC/ET_DYN file: %s\n", fname);
401			break;
402		}
403		rc = do_sort_32(ehdr, fname, custom_sort);
404		break;
405	case ELFCLASS64:
406		{
407		Elf64_Ehdr *const ghdr = (Elf64_Ehdr *)ehdr;
408		if (r2(&ghdr->e_ehsize) != sizeof(Elf64_Ehdr) ||
409		    r2(&ghdr->e_shentsize) != sizeof(Elf64_Shdr)) {
410			fprintf(stderr,
411				"unrecognized ET_EXEC/ET_DYN file: %s\n",
412				fname);
413			break;
414		}
415		rc = do_sort_64(ghdr, fname, custom_sort);
416		}
417		break;
418	default:
419		fprintf(stderr, "unrecognized ELF class %d %s\n",
420			ehdr->e_ident[EI_CLASS], fname);
421		break;
422	}
423
424	return rc;
425}
426
427int main(int argc, char *argv[])
428{
429	int i, n_error = 0;  /* gcc-4.3.0 false positive complaint */
430	size_t size = 0;
431	void *addr = NULL;
432
433	if (argc < 2) {
434		fprintf(stderr, "usage: sorttable vmlinux...\n");
435		return 0;
436	}
437
438	/* Process each file in turn, allowing deep failure. */
439	for (i = 1; i < argc; i++) {
440		addr = mmap_file(argv[i], &size);
441		if (!addr) {
442			++n_error;
443			continue;
444		}
445
446		if (do_file(argv[i], addr))
447			++n_error;
448
449		munmap(addr, size);
450	}
451
452	return !!n_error;
453}
454