[mirror_ubuntu-jammy-kernel.git] / tools / perf / util / syscalltbl.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * System call table mapper
 *
 * (C) 2016 Arnaldo Carvalho de Melo <acme@redhat.com>
 */

#include "syscalltbl.h"
#include <stdlib.h>
#include <linux/compiler.h>

#ifdef HAVE_SYSCALL_TABLE_SUPPORT
#include <linux/zalloc.h>
#include <string.h>
#include "string2.h"

#if defined(__x86_64__)
#include <asm/syscalls_64.c>
const int syscalltbl_native_max_id = SYSCALLTBL_x86_64_MAX_ID;
static const char **syscalltbl_native = syscalltbl_x86_64;
#elif defined(__s390x__)
#include <asm/syscalls_64.c>
const int syscalltbl_native_max_id = SYSCALLTBL_S390_64_MAX_ID;
static const char **syscalltbl_native = syscalltbl_s390_64;
#elif defined(__powerpc64__)
#include <asm/syscalls_64.c>
const int syscalltbl_native_max_id = SYSCALLTBL_POWERPC_64_MAX_ID;
static const char **syscalltbl_native = syscalltbl_powerpc_64;
#elif defined(__powerpc__)
#include <asm/syscalls_32.c>
const int syscalltbl_native_max_id = SYSCALLTBL_POWERPC_32_MAX_ID;
static const char **syscalltbl_native = syscalltbl_powerpc_32;
#elif defined(__aarch64__)
#include <asm/syscalls.c>
const int syscalltbl_native_max_id = SYSCALLTBL_ARM64_MAX_ID;
static const char **syscalltbl_native = syscalltbl_arm64;
#endif

struct syscall {
	int id;
	const char *name;
};

static int syscallcmpname(const void *vkey, const void *ventry)
{
	const char *key = vkey;
	const struct syscall *entry = ventry;

	return strcmp(key, entry->name);
}

static int syscallcmp(const void *va, const void *vb)
{
	const struct syscall *a = va, *b = vb;

	return strcmp(a->name, b->name);
}

static int syscalltbl__init_native(struct syscalltbl *tbl)
{
	int nr_entries = 0, i, j;
	struct syscall *entries;

	for (i = 0; i <= syscalltbl_native_max_id; ++i)
		if (syscalltbl_native[i])
			++nr_entries;

	entries = tbl->syscalls.entries = malloc(sizeof(struct syscall) * nr_entries);
	if (tbl->syscalls.entries == NULL)
		return -1;

	for (i = 0, j = 0; i <= syscalltbl_native_max_id; ++i) {
		if (syscalltbl_native[i]) {
			entries[j].name = syscalltbl_native[i];
			entries[j].id = i;
			++j;
		}
	}

	qsort(tbl->syscalls.entries, nr_entries, sizeof(struct syscall), syscallcmp);
	tbl->syscalls.nr_entries = nr_entries;
	tbl->syscalls.max_id	 = syscalltbl_native_max_id;
	return 0;
}

struct syscalltbl *syscalltbl__new(void)
{
	struct syscalltbl *tbl = malloc(sizeof(*tbl));
	if (tbl) {
		if (syscalltbl__init_native(tbl)) {
			free(tbl);
			return NULL;
		}
	}
	return tbl;
}

void syscalltbl__delete(struct syscalltbl *tbl)
{
	zfree(&tbl->syscalls.entries);
	free(tbl);
}

const char *syscalltbl__name(const struct syscalltbl *tbl __maybe_unused, int id)
{
	return id <= syscalltbl_native_max_id ? syscalltbl_native[id]: NULL;
}

int syscalltbl__id(struct syscalltbl *tbl, const char *name)
{
	struct syscall *sc = bsearch(name, tbl->syscalls.entries,
				     tbl->syscalls.nr_entries, sizeof(*sc),
				     syscallcmpname);

	return sc ? sc->id : -1;
}

int syscalltbl__strglobmatch_next(struct syscalltbl *tbl, const char *syscall_glob, int *idx)
{
	int i;
	struct syscall *syscalls = tbl->syscalls.entries;

	for (i = *idx + 1; i < tbl->syscalls.nr_entries; ++i) {
		if (strglobmatch(syscalls[i].name, syscall_glob)) {
			*idx = i;
			return syscalls[i].id;
		}
	}

	return -1;
}

int syscalltbl__strglobmatch_first(struct syscalltbl *tbl, const char *syscall_glob, int *idx)
{
	*idx = -1;
	return syscalltbl__strglobmatch_next(tbl, syscall_glob, idx);
}

#else /* HAVE_SYSCALL_TABLE_SUPPORT */

#include <libaudit.h>

struct syscalltbl *syscalltbl__new(void)
{
	struct syscalltbl *tbl = malloc(sizeof(*tbl));
	if (tbl)
		tbl->audit_machine = audit_detect_machine();
	return tbl;
}

void syscalltbl__delete(struct syscalltbl *tbl)
{
	free(tbl);
}

const char *syscalltbl__name(const struct syscalltbl *tbl, int id)
{
	return audit_syscall_to_name(id, tbl->audit_machine);
}

int syscalltbl__id(struct syscalltbl *tbl, const char *name)
{
	return audit_name_to_syscall(name, tbl->audit_machine);
}

int syscalltbl__strglobmatch_next(struct syscalltbl *tbl __maybe_unused,
				  const char *syscall_glob __maybe_unused, int *idx __maybe_unused)
{
	return -1;
}

int syscalltbl__strglobmatch_first(struct syscalltbl *tbl, const char *syscall_glob, int *idx)
{
	return syscalltbl__strglobmatch_next(tbl, syscall_glob, idx);
}
#endif /* HAVE_SYSCALL_TABLE_SUPPORT */
Commit	Line	Data
2025cf9e	1	// SPDX-License-Identifier: GPL-2.0-only
fd0db102 ACM	2	/*
	3	* System call table mapper
	4	*
	5	* (C) 2016 Arnaldo Carvalho de Melo <acme@redhat.com>
fd0db102 ACM	6	*/
	7
	8	#include "syscalltbl.h"
5af56fab	9	#include <stdlib.h>
090657c9	10	#include <linux/compiler.h>
5af56fab	11
22e9af4e	12	#ifdef HAVE_SYSCALL_TABLE_SUPPORT
7f7c536f	13	#include <linux/zalloc.h>
fd0db102	14	#include <string.h>
89be3f8a	15	#include "string2.h"
5af56fab	16
1b700c99 ACM	17	#if defined(__x86_64__)
	18	#include <asm/syscalls_64.c>
	19	const int syscalltbl_native_max_id = SYSCALLTBL_x86_64_MAX_ID;
	20	static const char **syscalltbl_native = syscalltbl_x86_64;
901bb028 HB	21	#elif defined(__s390x__)
	22	#include <asm/syscalls_64.c>
	23	const int syscalltbl_native_max_id = SYSCALLTBL_S390_64_MAX_ID;
	24	static const char **syscalltbl_native = syscalltbl_s390_64;
4281da23 RB	25	#elif defined(__powerpc64__)
	26	#include <asm/syscalls_64.c>
	27	const int syscalltbl_native_max_id = SYSCALLTBL_POWERPC_64_MAX_ID;
	28	static const char **syscalltbl_native = syscalltbl_powerpc_64;
	29	#elif defined(__powerpc__)
	30	#include <asm/syscalls_32.c>
	31	const int syscalltbl_native_max_id = SYSCALLTBL_POWERPC_32_MAX_ID;
	32	static const char **syscalltbl_native = syscalltbl_powerpc_32;
a7f660d6 KP	33	#elif defined(__aarch64__)
	34	#include <asm/syscalls.c>
	35	const int syscalltbl_native_max_id = SYSCALLTBL_ARM64_MAX_ID;
	36	static const char **syscalltbl_native = syscalltbl_arm64;
1b700c99 ACM	37	#endif
1b700c99 ACM	38
5af56fab ACM	39	struct syscall {
	40	int id;
	41	const char *name;
	42	};
fd0db102	43
5af56fab ACM	44	static int syscallcmpname(const void vkey, const void ventry)
	45	{
	46	const char *key = vkey;
	47	const struct syscall *entry = ventry;
	48
	49	return strcmp(key, entry->name);
	50	}
	51
	52	static int syscallcmp(const void va, const void vb)
	53	{
	54	const struct syscall a = va, b = vb;
	55
	56	return strcmp(a->name, b->name);
	57	}
	58
	59	static int syscalltbl__init_native(struct syscalltbl *tbl)
	60	{
	61	int nr_entries = 0, i, j;
	62	struct syscall *entries;
	63
	64	for (i = 0; i <= syscalltbl_native_max_id; ++i)
	65	if (syscalltbl_native[i])
	66	++nr_entries;
	67
	68	entries = tbl->syscalls.entries = malloc(sizeof(struct syscall) * nr_entries);
	69	if (tbl->syscalls.entries == NULL)
	70	return -1;
	71
	72	for (i = 0, j = 0; i <= syscalltbl_native_max_id; ++i) {
	73	if (syscalltbl_native[i]) {
	74	entries[j].name = syscalltbl_native[i];
	75	entries[j].id = i;
	76	++j;
	77	}
	78	}
	79
	80	qsort(tbl->syscalls.entries, nr_entries, sizeof(struct syscall), syscallcmp);
	81	tbl->syscalls.nr_entries = nr_entries;
30a910d7	82	tbl->syscalls.max_id = syscalltbl_native_max_id;
5af56fab ACM	83	return 0;
5af56fab ACM	84	}
fd0db102 ACM	85
	86	struct syscalltbl *syscalltbl__new(void)
	87	{
	88	struct syscalltbl tbl = malloc(sizeof(tbl));
	89	if (tbl) {
5af56fab ACM	90	if (syscalltbl__init_native(tbl)) {
	91	free(tbl);
	92	return NULL;
	93	}
fd0db102 ACM	94	}
	95	return tbl;
	96	}
	97
5af56fab ACM	98	void syscalltbl__delete(struct syscalltbl *tbl)
	99	{
	100	zfree(&tbl->syscalls.entries);
	101	free(tbl);
	102	}
	103
	104	const char syscalltbl__name(const struct syscalltbl tbl __maybe_unused, int id)
	105	{
	106	return id <= syscalltbl_native_max_id ? syscalltbl_native[id]: NULL;
	107	}
	108
	109	int syscalltbl__id(struct syscalltbl tbl, const char name)
	110	{
	111	struct syscall *sc = bsearch(name, tbl->syscalls.entries,
	112	tbl->syscalls.nr_entries, sizeof(*sc),
	113	syscallcmpname);
	114
	115	return sc ? sc->id : -1;
	116	}
	117
89be3f8a ACM	118	int syscalltbl__strglobmatch_next(struct syscalltbl tbl, const char syscall_glob, int *idx)
	119	{
	120	int i;
	121	struct syscall *syscalls = tbl->syscalls.entries;
	122
	123	for (i = *idx + 1; i < tbl->syscalls.nr_entries; ++i) {
	124	if (strglobmatch(syscalls[i].name, syscall_glob)) {
	125	*idx = i;
	126	return syscalls[i].id;
	127	}
	128	}
	129
	130	return -1;
	131	}
	132
	133	int syscalltbl__strglobmatch_first(struct syscalltbl tbl, const char syscall_glob, int *idx)
	134	{
	135	*idx = -1;
	136	return syscalltbl__strglobmatch_next(tbl, syscall_glob, idx);
	137	}
	138
22e9af4e	139	#else /* HAVE_SYSCALL_TABLE_SUPPORT */
5af56fab ACM	140
	141	#include <libaudit.h>
	142
	143	struct syscalltbl *syscalltbl__new(void)
	144	{
	145	struct syscalltbl tbl = malloc(sizeof(tbl));
	146	if (tbl)
	147	tbl->audit_machine = audit_detect_machine();
	148	return tbl;
	149	}
	150
fd0db102 ACM	151	void syscalltbl__delete(struct syscalltbl *tbl)
	152	{
	153	free(tbl);
	154	}
	155
	156	const char syscalltbl__name(const struct syscalltbl tbl, int id)
	157	{
	158	return audit_syscall_to_name(id, tbl->audit_machine);
	159	}
	160
	161	int syscalltbl__id(struct syscalltbl tbl, const char name)
	162	{
	163	return audit_name_to_syscall(name, tbl->audit_machine);
	164	}
89be3f8a ACM	165
	166	int syscalltbl__strglobmatch_next(struct syscalltbl *tbl __maybe_unused,
	167	const char syscall_glob __maybe_unused, int idx __maybe_unused)
	168	{
	169	return -1;
	170	}
	171
	172	int syscalltbl__strglobmatch_first(struct syscalltbl tbl, const char syscall_glob, int *idx)
	173	{
	174	return syscalltbl__strglobmatch_next(tbl, syscall_glob, idx);
	175	}
22e9af4e	176	#endif /* HAVE_SYSCALL_TABLE_SUPPORT */