// SPDX-License-Identifier: GPL-2.0-only/* * sorttable.c: Sort the kernel's table * * Added ORC unwind tables sort support and other updates: * Copyright (C) 1999-2019 Alibaba Group Holding Limited. by: * Shile Zhang <shile.zhang@linux.alibaba.com> * * Copyright 2011 - 2012 Cavium, Inc. * * Based on code taken from recortmcount.c which is: * * Copyright 2009 John F. Reiser <jreiser@BitWagon.com>.  All rights reserved. * * Restructured to fit Linux format, as well as other updates: * Copyright 2010 Steven Rostedt <srostedt@redhat.com>, Red Hat Inc. */ /* * Strategy: alter the vmlinux file in-place. */ #include <sys/types.h>#include <sys/stat.h>#include <getopt.h>#include <fcntl.h>#include <stdio.h>#include <stdlib.h>#include <stdbool.h>#include <string.h>#include <unistd.h>#include <errno.h>#include <pthread.h> #include "elf-parse.h" #ifndef EM_ARCOMPACT#define EM_ARCOMPACT	93#endif #ifndef EM_XTENSA#define EM_XTENSA	94#endif #ifndef EM_AARCH64#define EM_AARCH64	183#endif #ifndef EM_MICROBLAZE#define EM_MICROBLAZE	189#endif #ifndef EM_ARCV2#define EM_ARCV2	195#endif #ifndef EM_RISCV#define EM_RISCV	243#endif #ifndef EM_LOONGARCH#define EM_LOONGARCH	258#endif typedef void (*table_sort_t)(char *, int); /* * Move reserved section indices SHN_LORESERVE..SHN_HIRESERVE out of * the way to -256..-1, to avoid conflicting with real section * indices. */#define SPECIAL(i) ((i) - (SHN_HIRESERVE + 1)) static inline int is_shndx_special(unsigned int i){	return i != SHN_XINDEX && i >= SHN_LORESERVE && i <= SHN_HIRESERVE;} /* Accessor for sym->st_shndx, hides ugliness of "64k sections" */static inline unsigned int get_secindex(unsigned int shndx,					unsigned int sym_offs,					const Elf32_Word *symtab_shndx_start){	if (is_shndx_special(shndx))		return SPECIAL(shndx);	if (shndx != SHN_XINDEX)		return shndx;	return elf_parser.r(&symtab_shndx_start[sym_offs]);} static int compare_extable_32(const void *a, const void *b){	Elf32_Addr av = elf_parser.r(a);	Elf32_Addr bv = elf_parser.r(b); 	if (av < bv)		return -1;	return av > bv;} static int compare_extable_64(const void *a, const void *b){	Elf64_Addr av = elf_parser.r8(a);	Elf64_Addr bv = elf_parser.r8(b); 	if (av < bv)		return -1;	return av > bv;} static int (*compare_extable)(const void *a, const void *b); static inline void *get_index(void *start, int entsize, int index){	return start + (entsize * index);} static int extable_ent_size;static int long_size; #define ERRSTR_MAXSZ	256 #ifdef UNWINDER_ORC_ENABLED/* ORC unwinder only support X86_64 */#include <asm/orc_types.h> static char g_err[ERRSTR_MAXSZ];static int *g_orc_ip_table;static struct orc_entry *g_orc_table; static pthread_t orc_sort_thread; static inline unsigned long orc_ip(const int *ip){	return (unsigned long)ip + *ip;} static int orc_sort_cmp(const void *_a, const void *_b){	struct orc_entry *orc_a, *orc_b;	const int *a = g_orc_ip_table + *(int *)_a;	const int *b = g_orc_ip_table + *(int *)_b;	unsigned long a_val = orc_ip(a);	unsigned long b_val = orc_ip(b); 	if (a_val > b_val)		return 1;	if (a_val < b_val)		return -1; 	/*	 * The "weak" section terminator entries need to always be on the left	 * to ensure the lookup code skips them in favor of real entries.	 * These terminator entries exist to handle any gaps created by	 * whitelisted .o files which didn't get objtool generation.	 */	orc_a = g_orc_table + (a - g_orc_ip_table);	orc_b = g_orc_table + (b - g_orc_ip_table);	if (orc_a->type == ORC_TYPE_UNDEFINED && orc_b->type == ORC_TYPE_UNDEFINED)		return 0;	return orc_a->type == ORC_TYPE_UNDEFINED ? -1 : 1;} static void *sort_orctable(void *arg){	int i;	int *idxs = NULL;	int *tmp_orc_ip_table = NULL;	struct orc_entry *tmp_orc_table = NULL;	unsigned int *orc_ip_size = (unsigned int *)arg;	unsigned int num_entries = *orc_ip_size / sizeof(int);	unsigned int orc_size = num_entries * sizeof(struct orc_entry); 	idxs = (int *)malloc(*orc_ip_size);	if (!idxs) {		snprintf(g_err, ERRSTR_MAXSZ, "malloc idxs: %s",			 strerror(errno));		pthread_exit(g_err);	} 	tmp_orc_ip_table = (int *)malloc(*orc_ip_size);	if (!tmp_orc_ip_table) {		snprintf(g_err, ERRSTR_MAXSZ, "malloc tmp_orc_ip_table: %s",			 strerror(errno));		pthread_exit(g_err);	} 	tmp_orc_table = (struct orc_entry *)malloc(orc_size);	if (!tmp_orc_table) {		snprintf(g_err, ERRSTR_MAXSZ, "malloc tmp_orc_table: %s",			 strerror(errno));		pthread_exit(g_err);	} 	/* initialize indices array, convert ip_table to absolute address */	for (i = 0; i < num_entries; i++) {		idxs[i] = i;		tmp_orc_ip_table[i] = g_orc_ip_table[i] + i * sizeof(int);	}	memcpy(tmp_orc_table, g_orc_table, orc_size); 	qsort(idxs, num_entries, sizeof(int), orc_sort_cmp); 	for (i = 0; i < num_entries; i++) {		if (idxs[i] == i)			continue; 		/* convert back to relative address */		g_orc_ip_table[i] = tmp_orc_ip_table[idxs[i]] - i * sizeof(int);		g_orc_table[i] = tmp_orc_table[idxs[i]];	} 	free(idxs);	free(tmp_orc_ip_table);	free(tmp_orc_table);	pthread_exit(NULL);}#endif #ifdef MCOUNT_SORT_ENABLED static int compare_values_64(const void *a, const void *b){	uint64_t av = *(uint64_t *)a;	uint64_t bv = *(uint64_t *)b; 	if (av < bv)		return -1;	return av > bv;} static int compare_values_32(const void *a, const void *b){	uint32_t av = *(uint32_t *)a;	uint32_t bv = *(uint32_t *)b; 	if (av < bv)		return -1;	return av > bv;} static int (*compare_values)(const void *a, const void *b); /* Only used for sorting mcount table */static void rela_write_addend(Elf_Rela *rela, uint64_t val){	elf_parser.rela_write_addend(rela, val);} struct func_info {	uint64_t	addr;	uint64_t	size;}; /* List of functions created by: nm -S vmlinux */static struct func_info *function_list;static int function_list_size; /* Allocate functions in 1k blocks */#define FUNC_BLK_SIZE	1024#define FUNC_BLK_MASK	(FUNC_BLK_SIZE - 1) static int add_field(uint64_t addr, uint64_t size){	struct func_info *fi;	int fsize = function_list_size; 	if (!(fsize & FUNC_BLK_MASK)) {		fsize += FUNC_BLK_SIZE;		fi = realloc(function_list, fsize * sizeof(struct func_info));		if (!fi)			return -1;		function_list = fi;	}	fi = &function_list[function_list_size++];	fi->addr = addr;	fi->size = size;	return 0;} /* Used for when mcount/fentry is before the function entry */static int before_func; /* Only return match if the address lies inside the function size */static int cmp_func_addr(const void *K, const void *A){	uint64_t key = *(const uint64_t *)K;	const struct func_info *a = A; 	if (key + before_func < a->addr)		return -1;	return key >= a->addr + a->size;} /* Find the function in function list that is bounded by the function size */static int find_func(uint64_t key){	return bsearch(&key, function_list, function_list_size,		       sizeof(struct func_info), cmp_func_addr) != NULL;} static int cmp_funcs(const void *A, const void *B){	const struct func_info *a = A;	const struct func_info *b = B; 	if (a->addr < b->addr)		return -1;	return a->addr > b->addr;} static int parse_symbols(const char *fname){	FILE *fp;	char addr_str[20]; /* Only need 17, but round up to next int size */	char size_str[20];	char type; 	fp = fopen(fname, "r");	if (!fp) {		perror(fname);		return -1;	} 	while (fscanf(fp, "%16s %16s %c %*s\n", addr_str, size_str, &type) == 3) {		uint64_t addr;		uint64_t size; 		/* Only care about functions */		if (type != 't' && type != 'T' && type != 'W')			continue; 		addr = strtoull(addr_str, NULL, 16);		size = strtoull(size_str, NULL, 16);		if (add_field(addr, size) < 0)			return -1;	}	fclose(fp); 	qsort(function_list, function_list_size, sizeof(struct func_info), cmp_funcs); 	return 0;} static pthread_t mcount_sort_thread;static bool sort_reloc; static long rela_type; static char m_err[ERRSTR_MAXSZ]; struct elf_mcount_loc {	Elf_Ehdr *ehdr;	Elf_Shdr *init_data_sec;	uint64_t start_mcount_loc;	uint64_t stop_mcount_loc;}; /* Fill the array with the content of the relocs */static int fill_relocs(void *ptr, uint64_t size, Elf_Ehdr *ehdr, uint64_t start_loc){	Elf_Shdr *shdr_start;	Elf_Rela *rel;	unsigned int shnum;	unsigned int count = 0;	int shentsize;	void *array_end = ptr + size; 	shdr_start = (Elf_Shdr *)((char *)ehdr + ehdr_shoff(ehdr));	shentsize = ehdr_shentsize(ehdr); 	shnum = ehdr_shnum(ehdr);	if (shnum == SHN_UNDEF)		shnum = shdr_size(shdr_start); 	for (int i = 0; i < shnum; i++) {		Elf_Shdr *shdr = get_index(shdr_start, shentsize, i);		void *end; 		if (shdr_type(shdr) != SHT_RELA)			continue; 		rel = (void *)ehdr + shdr_offset(shdr);		end = (void *)rel + shdr_size(shdr); 		for (; (void *)rel < end; rel = (void *)rel + shdr_entsize(shdr)) {			uint64_t offset = rela_offset(rel); 			if (offset >= start_loc && offset < start_loc + size) {				if (ptr + long_size > array_end) {					snprintf(m_err, ERRSTR_MAXSZ,						 "Too many relocations");					return -1;				} 				/* Make sure this has the correct type */				if (rela_info(rel) != rela_type) {					snprintf(m_err, ERRSTR_MAXSZ,						"rela has type %lx but expected %lx\n",						(long)rela_info(rel), rela_type);					return -1;				} 				if (long_size == 4)					*(uint32_t *)ptr = rela_addend(rel);				else					*(uint64_t *)ptr = rela_addend(rel);				ptr += long_size;				count++;			}		}	}	return count;} /* Put the sorted vals back into the relocation elements */static void replace_relocs(void *ptr, uint64_t size, Elf_Ehdr *ehdr, uint64_t start_loc){	Elf_Shdr *shdr_start;	Elf_Rela *rel;	unsigned int shnum;	int shentsize; 	shdr_start = (Elf_Shdr *)((char *)ehdr + ehdr_shoff(ehdr));	shentsize = ehdr_shentsize(ehdr); 	shnum = ehdr_shnum(ehdr);	if (shnum == SHN_UNDEF)		shnum = shdr_size(shdr_start); 	for (int i = 0; i < shnum; i++) {		Elf_Shdr *shdr = get_index(shdr_start, shentsize, i);		void *end; 		if (shdr_type(shdr) != SHT_RELA)			continue; 		rel = (void *)ehdr + shdr_offset(shdr);		end = (void *)rel + shdr_size(shdr); 		for (; (void *)rel < end; rel = (void *)rel + shdr_entsize(shdr)) {			uint64_t offset = rela_offset(rel); 			if (offset >= start_loc && offset < start_loc + size) {				if (long_size == 4)					rela_write_addend(rel, *(uint32_t *)ptr);				else					rela_write_addend(rel, *(uint64_t *)ptr);				ptr += long_size;			}		}	}} static int fill_addrs(void *ptr, uint64_t size, void *addrs){	void *end = ptr + size;	int count = 0; 	for (; ptr < end; ptr += long_size, addrs += long_size, count++) {		if (long_size == 4)			*(uint32_t *)ptr = elf_parser.r(addrs);		else			*(uint64_t *)ptr = elf_parser.r8(addrs);	}	return count;} static void replace_addrs(void *ptr, uint64_t size, void *addrs){	void *end = ptr + size; 	for (; ptr < end; ptr += long_size, addrs += long_size) {		if (long_size == 4)			elf_parser.w(*(uint32_t *)ptr, addrs);		else			elf_parser.w8(*(uint64_t *)ptr, addrs);	}} /* Sort the addresses stored between __start_mcount_loc to __stop_mcount_loc in vmlinux */static void *sort_mcount_loc(void *arg){	struct elf_mcount_loc *emloc = (struct elf_mcount_loc *)arg;	uint64_t offset = emloc->start_mcount_loc - shdr_addr(emloc->init_data_sec)					+ shdr_offset(emloc->init_data_sec);	uint64_t size = emloc->stop_mcount_loc - emloc->start_mcount_loc;	unsigned char *start_loc = (void *)emloc->ehdr + offset;	Elf_Ehdr *ehdr = emloc->ehdr;	void *e_msg = NULL;	void *vals;	int count; 	vals = malloc(long_size * size);	if (!vals) {		snprintf(m_err, ERRSTR_MAXSZ, "Failed to allocate sort array");		pthread_exit(m_err);	} 	if (sort_reloc) {

Lines 1–500 of 1005. Load more