1// SPDX-License-Identifier: GPL-2.0
  2#include <linux/compiler.h>
  3#include <linux/string.h>
  4#include <sys/mman.h>
  5#include <limits.h>
  6#include "debug.h"
  7#include "dso.h"
  8#include "machine.h"
  9#include "thread.h"
 10#include "symbol.h"
 11#include "map.h"
 12#include "util.h"
 13#include "tests.h"
 14
 15struct test_info {
 16	struct machine *machine;
 17	struct thread *thread;
 18};
 19
 20static int init_test_info(struct test_info *ti)
 21{
 22	ti->machine = machine__new_host();
 23	if (!ti->machine) {
 24		pr_debug("machine__new_host() failed!\n");
 25		return TEST_FAIL;
 26	}
 27
 28	/* Create a dummy thread */
 29	ti->thread = machine__findnew_thread(ti->machine, 100, 100);
 30	if (!ti->thread) {
 31		pr_debug("machine__findnew_thread() failed!\n");
 32		return TEST_FAIL;
 33	}
 34
 35	return TEST_OK;
 36}
 37
 38static void exit_test_info(struct test_info *ti)
 39{
 40	thread__put(ti->thread);
 41	machine__delete(ti->machine);
 42}
 43
 44struct dso_map {
 45	struct dso *dso;
 46	struct map *map;
 47};
 48
 49static int find_map_cb(struct map *map, void *d)
 50{
 51	struct dso_map *data = d;
 52
 53	if (map__dso(map) != data->dso)
 54		return 0;
 55	data->map = map;
 56	return 1;
 57}
 58
 59static struct map *find_module_map(struct machine *machine, struct dso *dso)
 60{
 61	struct dso_map data = { .dso = dso };
 62
 63	machine__for_each_kernel_map(machine, find_map_cb, &data);
 64
 65	return data.map;
 66}
 67
 68static void get_test_dso_filename(char *filename, size_t max_sz)
 69{
 70	if (dso_to_test)
 71		strlcpy(filename, dso_to_test, max_sz);
 72	else
 73		perf_exe(filename, max_sz);
 74}
 75
 76static int create_map(struct test_info *ti, char *filename, struct map **map_p)
 77{
 78	struct dso *dso = machine__findnew_dso(ti->machine, filename);
 79
 80	/*
 81	 * If 'filename' matches a current kernel module, must use a kernel
 82	 * map. Find the one that already exists.
 83	 */
 84	if (dso && dso__kernel(dso) != DSO_SPACE__USER) {
 85		*map_p = find_module_map(ti->machine, dso);
 86		dso__put(dso);
 87		if (!*map_p) {
 88			pr_debug("Failed to find map for current kernel module %s",
 89				 filename);
 90			return TEST_FAIL;
 91		}
 92		map__get(*map_p);
 93		return TEST_OK;
 94	}
 95
 96	dso__put(dso);
 97
 98	/* Create a dummy map at 0x100000 */
 99	*map_p = map__new(ti->machine, 0x100000, 0xffffffff, 0, NULL,
100			  PROT_EXEC, 0, NULL, filename, ti->thread);
101	if (!*map_p) {
102		pr_debug("Failed to create map!");
103		return TEST_FAIL;
104	}
105
106	return TEST_OK;
107}
108
109static int test_dso(struct dso *dso)
110{
111	struct symbol *last_sym = NULL;
112	struct rb_node *nd;
113	int ret = TEST_OK;
114
115	/* dso__fprintf() prints all the symbols */
116	if (verbose > 1)
117		dso__fprintf(dso, stderr);
118
119	for (nd = rb_first_cached(dso__symbols(dso)); nd; nd = rb_next(nd)) {
120		struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
121
122		if (sym->type != STT_FUNC && sym->type != STT_GNU_IFUNC)
123			continue;
124
125		/* Check for overlapping function symbols */
126		if (last_sym && sym->start < last_sym->end) {
127			pr_debug("Overlapping symbols:\n");
128			symbol__fprintf(last_sym, stderr);
129			symbol__fprintf(sym, stderr);
130			ret = TEST_FAIL;
131		}
132		/* Check for zero-length function symbol */
133		if (sym->start == sym->end) {
134			pr_debug("Zero-length symbol:\n");
135			symbol__fprintf(sym, stderr);
136			ret = TEST_FAIL;
137		}
138		last_sym = sym;
139	}
140
141	return ret;
142}
143
144static int subdivided_dso_cb(struct dso *dso, struct machine *machine __maybe_unused, void *d)
145{
146	struct dso *text_dso = d;
147
148	if (dso != text_dso && strstarts(dso__short_name(dso), dso__short_name(text_dso)))
149		if (test_dso(dso) != TEST_OK)
150			return -1;
151
152	return 0;
153}
154
155static int process_subdivided_dso(struct machine *machine, struct dso *dso)
156{
157	int ret;
158
159	ret = machine__for_each_dso(machine, subdivided_dso_cb, dso);
160
161	return ret < 0 ? TEST_FAIL : TEST_OK;
162}
163
164static int test_file(struct test_info *ti, char *filename)
165{
166	struct map *map = NULL;
167	int ret, nr;
168	struct dso *dso;
169
170	pr_debug("Testing %s\n", filename);
171
172	ret = create_map(ti, filename, &map);
173	if (ret != TEST_OK)
174		return ret;
175
176	dso = map__dso(map);
177	nr = dso__load(dso, map);
178	if (nr < 0) {
179		pr_debug("dso__load() failed!\n");
180		ret = TEST_FAIL;
181		goto out_put;
182	}
183
184	if (nr == 0) {
185		pr_debug("DSO has no symbols!\n");
186		ret = TEST_SKIP;
187		goto out_put;
188	}
189
190	ret = test_dso(dso);
191
192	/* Module dso is split into many dsos by section */
193	if (ret == TEST_OK && dso__kernel(dso) != DSO_SPACE__USER)
194		ret = process_subdivided_dso(ti->machine, dso);
195out_put:
196	map__put(map);
197
198	return ret;
199}
200
201static int test__symbols(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
202{
203	char filename[PATH_MAX];
204	struct test_info ti;
205	int ret;
206
207	ret = init_test_info(&ti);
208	if (ret != TEST_OK)
209		return ret;
210
211	get_test_dso_filename(filename, sizeof(filename));
212
213	ret = test_file(&ti, filename);
214
215	exit_test_info(&ti);
216
217	return ret;
218}
219
220DEFINE_SUITE("Symbols", symbols);