path: root/tools/perf/tests/symbols.c

// SPDX-License-Identifier: GPL-2.0
#include <linux/compiler.h>
#include <linux/string.h>
#include <sys/mman.h>
#include <inttypes.h>
#include <limits.h>
#include "debug.h"
#include "dso.h"
#include "env.h"
#include "machine.h"
#include "thread.h"
#include "symbol.h"
#include "map.h"
#include "util.h"
#include "tests.h"

struct test_info {
	struct perf_env host_env;
	struct machine *machine;
	struct thread *thread;
};

static int init_test_info(struct test_info *ti)
{
	perf_env__init(&ti->host_env);
	ti->machine = machine__new_host(&ti->host_env);
	if (!ti->machine) {
		pr_debug("machine__new_host() failed!\n");
		perf_env__exit(&ti->host_env);
		return TEST_FAIL;
	}

	/* Create a dummy thread */
	ti->thread = machine__findnew_thread(ti->machine, 100, 100);
	if (!ti->thread) {
		pr_debug("machine__findnew_thread() failed!\n");
		perf_env__exit(&ti->host_env);
		return TEST_FAIL;
	}

	return TEST_OK;
}

static void exit_test_info(struct test_info *ti)
{
	thread__put(ti->thread);
	machine__delete(ti->machine);
	perf_env__exit(&ti->host_env);
}

struct dso_map {
	struct dso *dso;
	struct map *map;
};

static int find_map_cb(struct map *map, void *d)
{
	struct dso_map *data = d;

	if (map__dso(map) != data->dso)
		return 0;
	data->map = map;
	return 1;
}

static struct map *find_module_map(struct machine *machine, struct dso *dso)
{
	struct dso_map data = { .dso = dso };

	machine__for_each_kernel_map(machine, find_map_cb, &data);

	return data.map;
}

static void get_test_dso_filename(char *filename, size_t max_sz)
{
	if (dso_to_test)
		strlcpy(filename, dso_to_test, max_sz);
	else
		perf_exe(filename, max_sz);
}

static int create_map(struct test_info *ti, char *filename, struct map **map_p)
{
	struct dso *dso = machine__findnew_dso(ti->machine, filename);

	/*
	 * If 'filename' matches a current kernel module, must use a kernel
	 * map. Find the one that already exists.
	 */
	if (dso && dso__kernel(dso) != DSO_SPACE__USER) {
		*map_p = find_module_map(ti->machine, dso);
		dso__put(dso);
		if (!*map_p) {
			pr_debug("Failed to find map for current kernel module %s",
				 filename);
			return TEST_FAIL;
		}
		map__get(*map_p);
		return TEST_OK;
	}

	dso__put(dso);

	/* Create a dummy map at 0x100000 */
	*map_p = map__new(ti->machine, 0x100000, 0xffffffff, 0, &dso_id_empty,
			  PROT_EXEC, /*flags=*/0, filename, ti->thread);
	if (!*map_p) {
		pr_debug("Failed to create map!");
		return TEST_FAIL;
	}

	return TEST_OK;
}

static int test_dso(struct dso *dso)
{
	struct symbol *last_sym = NULL;
	struct rb_node *nd;
	int ret = TEST_OK;

	/* dso__fprintf() prints all the symbols */
	if (verbose > 1)
		dso__fprintf(dso, stderr);

	for (nd = rb_first_cached(dso__symbols(dso)); nd; nd = rb_next(nd)) {
		struct symbol *sym = rb_entry(nd, struct symbol, rb_node);

		if (symbol__type(sym) != STT_FUNC && symbol__type(sym) != STT_GNU_IFUNC)
			continue;

		/* Check for overlapping function symbols */
		if (last_sym && sym->start < last_sym->end) {
			pr_debug("Overlapping symbols:\n");
			symbol__fprintf(last_sym, stderr);
			symbol__fprintf(sym, stderr);
			ret = TEST_FAIL;
		}
		/* Check for zero-length function symbol */
		if (sym->start == sym->end) {
			pr_debug("Zero-length symbol:\n");
			symbol__fprintf(sym, stderr);
			ret = TEST_FAIL;
		}
		last_sym = sym;
	}

	return ret;
}

static int subdivided_dso_cb(struct dso *dso, struct machine *machine __maybe_unused, void *d)
{
	struct dso *text_dso = d;

	if (dso != text_dso && strstarts(dso__short_name(dso), dso__short_name(text_dso)))
		if (test_dso(dso) != TEST_OK)
			return -1;

	return 0;
}

static int process_subdivided_dso(struct machine *machine, struct dso *dso)
{
	int ret;

	ret = machine__for_each_dso(machine, subdivided_dso_cb, dso);

	return ret < 0 ? TEST_FAIL : TEST_OK;
}

static int test_file(struct test_info *ti, char *filename)
{
	struct map *map = NULL;
	int ret, nr;
	struct dso *dso;

	pr_debug("Testing %s\n", filename);

	ret = create_map(ti, filename, &map);
	if (ret != TEST_OK)
		return ret;

	dso = map__dso(map);
	nr = dso__load(dso, map);
	if (nr < 0) {
		pr_debug("dso__load() failed!\n");
		ret = TEST_FAIL;
		goto out_put;
	}

	if (nr == 0) {
		pr_debug("DSO has no symbols!\n");
		ret = TEST_SKIP;
		goto out_put;
	}

	ret = test_dso(dso);

	/* Module dso is split into many dsos by section */
	if (ret == TEST_OK && dso__kernel(dso) != DSO_SPACE__USER)
		ret = process_subdivided_dso(ti->machine, dso);
out_put:
	map__put(map);

	return ret;
}

static int test__symbols(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
{
	char filename[PATH_MAX];
	struct test_info ti;
	int ret;

	ret = init_test_info(&ti);
	if (ret != TEST_OK)
		return ret;

	get_test_dso_filename(filename, sizeof(filename));

	ret = test_file(&ti, filename);

	exit_test_info(&ti);

	return ret;
}

struct kallsyms_sym {
	u64 start;
	const char *name;
};

/*
 * kallsyms from an x86 host where nf_tables was loaded in the page right
 * after the last symbol of dca, plus a kernel symbol followed closely by a
 * module and a module far away from the others.
 */
static const struct kallsyms_sym kallsyms_syms[] = {
	{ 0xffffffff81000000, "_stext" },
	{ 0xffffffff81000ff0, "last_kernel_symbol" },
	{ 0xffffffff81001000, "near_module_symbol\t[near]" },
	{ 0xffffffffc0c4aa40, "dca_exit\t[dca]" },
	{ 0xffffffffc0c4aa50, "dca_sysfs_exit\t[dca]" },
	{ 0xffffffffc0c4b000, "__nft_trace_packet\t[nf_tables]" },
	{ 0xffffffffc0c4b0b0, "nft_do_chain\t[nf_tables]" },
	{ 0xffffffffc0c4b4e0, "nf_tables_core_module_exit\t[nf_tables]" },
	{ 0xffffffffc2000000, "far_module_symbol\t[far]" },
};

static int check_symbol(struct dso *dso, u64 addr, const char *name, u64 end)
{
	struct symbol *sym = dso__find_symbol_nocache(dso, addr);

	if (!sym || strcmp(sym->name, name)) {
		pr_debug("%#" PRIx64 ": expected %s, got %s\n", addr, name,
			 sym ? sym->name : "no symbol");
		return TEST_FAIL;
	}
	if (sym->end != end) {
		pr_debug("%s: expected end %#" PRIx64 ", got %#" PRIx64 "\n",
			 name, end, sym->end);
		return TEST_FAIL;
	}
	return TEST_OK;
}

static int test__kallsyms_fixup_end(struct test_suite *test __maybe_unused,
				    int subtest __maybe_unused)
{
	struct dso *dso = dso__new("[kernel.kallsyms]");
	int ret = TEST_FAIL;

	if (!dso)
		return TEST_FAIL;

	for (unsigned int i = 0; i < ARRAY_SIZE(kallsyms_syms); i++) {
		struct symbol *sym = symbol__new(kallsyms_syms[i].start, 0, 0, 0,
						 kallsyms_syms[i].name);

		if (!sym)
			goto out;
		symbols__insert(dso__symbols(dso), sym);
	}

	symbols__fixup_end(dso__symbols(dso), true);

	ret = TEST_OK;
	/* The next symbol is too close for the end of the page. */
	if (check_symbol(dso, 0xffffffff81000ff8, "last_kernel_symbol",
			 0xffffffff81001000))
		ret = TEST_FAIL;
	if (check_symbol(dso, 0xffffffffc0c4aa58, "dca_sysfs_exit\t[dca]",
			 0xffffffffc0c4b000))
		ret = TEST_FAIL;
	if (check_symbol(dso, 0xffffffffc0c4b280, "nft_do_chain\t[nf_tables]",
			 0xffffffffc0c4b4e0))
		ret = TEST_FAIL;

	/* Far from the next module, the end of the page is still used. */
	if (check_symbol(dso, 0xffffffffc0c4b4f0,
			 "nf_tables_core_module_exit\t[nf_tables]",
			 0xffffffffc0c4d000))
		ret = TEST_FAIL;
	if (check_symbol(dso, 0xffffffff81001008, "near_module_symbol\t[near]",
			 0xffffffff81002000))
		ret = TEST_FAIL;
out:
	dso__put(dso);
	return ret;
}

static struct test_case tests__symbols[] = {
	TEST_CASE("Symbols", symbols),
	TEST_CASE("Kallsyms symbol ends", kallsyms_fixup_end),
	{ .name = NULL, }
};

struct test_suite suite__symbols = {
	.desc = "Symbols",
	.test_cases = tests__symbols,
};