builtin-test.c 8.8 KB
Newer Older
1 2 3 4 5
/*
 * builtin-test.c
 *
 * Builtin regression testing command: ever growing number of sanity tests
 */
6 7
#include <unistd.h>
#include <string.h>
8
#include "builtin.h"
9
#include "hist.h"
10
#include "intlist.h"
11
#include "tests.h"
12 13
#include "debug.h"
#include "color.h"
14
#include <subcmd/parse-options.h>
15
#include "symbol.h"
16

17 18 19 20 21 22 23
struct test __weak arch_tests[] = {
	{
		.func = NULL,
	},
};

static struct test generic_tests[] = {
24 25 26 27
	{
		.desc = "vmlinux symtab matches kallsyms",
		.func = test__vmlinux_matches_kallsyms,
	},
28
	{
29 30
		.desc = "detect openat syscall event",
		.func = test__openat_syscall_event,
31
	},
32
	{
33 34
		.desc = "detect openat syscall event on all cpus",
		.func = test__openat_syscall_event_on_all_cpus,
35
	},
36 37 38 39
	{
		.desc = "read samples using the mmap interface",
		.func = test__basic_mmap,
	},
40 41
	{
		.desc = "parse events tests",
42
		.func = test__parse_events,
43
	},
44 45 46 47
	{
		.desc = "Validate PERF_RECORD_* events & perf_sample fields",
		.func = test__PERF_RECORD,
	},
48 49
	{
		.desc = "Test perf pmu format parsing",
50
		.func = test__pmu,
51
	},
52
	{
53
		.desc = "Test dso data read",
54
		.func = test__dso_data,
55
	},
56 57 58 59
	{
		.desc = "Test dso data cache",
		.func = test__dso_data_cache,
	},
60 61 62 63
	{
		.desc = "Test dso data reopen",
		.func = test__dso_data_reopen,
	},
64 65
	{
		.desc = "roundtrip evsel->name check",
66
		.func = test__perf_evsel__roundtrip_name_test,
67
	},
68 69
	{
		.desc = "Check parsing of sched tracepoints fields",
70
		.func = test__perf_evsel__tp_sched_test,
71
	},
72
	{
73 74
		.desc = "Generate and check syscalls:sys_enter_openat event fields",
		.func = test__syscall_openat_tp_fields,
75
	},
76 77
	{
		.desc = "struct perf_event_attr setup",
78
		.func = test__attr,
79
	},
80
	{
81
		.desc = "Test matching and linking multiple hists",
82 83
		.func = test__hists_link,
	},
84
	{
85
		.desc = "Try 'import perf' in python, checking link problems",
86 87
		.func = test__python_use,
	},
88 89 90 91
	{
		.desc = "Test breakpoint overflow signal handler",
		.func = test__bp_signal,
	},
92 93 94 95
	{
		.desc = "Test breakpoint overflow sampling",
		.func = test__bp_signal_overflow,
	},
96 97 98 99
	{
		.desc = "Test number of exit event of a simple workload",
		.func = test__task_exit,
	},
100 101 102 103
	{
		.desc = "Test software clock events have valid period values",
		.func = test__sw_clock_freq,
	},
104 105 106 107
	{
		.desc = "Test object code reading",
		.func = test__code_reading,
	},
108 109 110 111
	{
		.desc = "Test sample parsing",
		.func = test__sample_parsing,
	},
112 113 114 115
	{
		.desc = "Test using a dummy software event to keep tracking",
		.func = test__keep_tracking,
	},
116 117 118 119
	{
		.desc = "Test parsing with no sample_id_all bit set",
		.func = test__parse_no_sample_id_all,
	},
120 121 122 123
	{
		.desc = "Test filtering hist entries",
		.func = test__hists_filter,
	},
124 125 126 127
	{
		.desc = "Test mmap thread lookup",
		.func = test__mmap_thread_lookup,
	},
128 129 130 131
	{
		.desc = "Test thread mg sharing",
		.func = test__thread_mg_share,
	},
132 133 134 135
	{
		.desc = "Test output sorting of hist entries",
		.func = test__hists_output,
	},
136 137 138 139
	{
		.desc = "Test cumulation of child hist entries",
		.func = test__hists_cumulate,
	},
140 141 142 143
	{
		.desc = "Test tracking with sched_switch",
		.func = test__switch_tracking,
	},
144
	{
145 146
		.desc = "Filter fds with revents mask in a fdarray",
		.func = test__fdarray__filter,
147
	},
148
	{
149 150
		.desc = "Add fd to a fdarray, making it autogrow",
		.func = test__fdarray__add,
151
	},
152 153 154 155
	{
		.desc = "Test kmod_path__parse function",
		.func = test__kmod_path__parse,
	},
156 157 158 159
	{
		.desc = "Test thread map",
		.func = test__thread_map,
	},
160 161 162
	{
		.desc = "Test LLVM searching and compiling",
		.func = test__llvm,
163 164 165 166 167
		.subtest = {
			.skip_if_fail	= true,
			.get_nr		= test__llvm_subtest_get_nr,
			.get_desc	= test__llvm_subtest_get_desc,
		},
168
	},
169 170 171 172
	{
		.desc = "Test topology in session",
		.func = test_session_topology,
	},
173 174 175
	{
		.desc = "Test BPF filter",
		.func = test__bpf,
176 177 178 179 180
		.subtest = {
			.skip_if_fail	= true,
			.get_nr		= test__bpf_subtest_get_nr,
			.get_desc	= test__bpf_subtest_get_desc,
		},
181
	},
182 183 184 185
	{
		.desc = "Test thread map synthesize",
		.func = test__thread_map_synthesize,
	},
186 187 188 189
	{
		.desc = "Test cpu map synthesize",
		.func = test__cpu_map_synthesize,
	},
190 191 192 193
	{
		.desc = "Test stat config synthesize",
		.func = test__synthesize_stat_config,
	},
194 195 196 197 198
	{
		.func = NULL,
	},
};

199 200 201 202 203
static struct test *tests[] = {
	generic_tests,
	arch_tests,
};

204
static bool perf_test__matches(struct test *test, int curr, int argc, const char *argv[])
205
{
206 207 208 209 210 211 212 213 214 215 216 217 218 219
	int i;

	if (argc == 0)
		return true;

	for (i = 0; i < argc; ++i) {
		char *end;
		long nr = strtoul(argv[i], &end, 10);

		if (*end == '\0') {
			if (nr == curr + 1)
				return true;
			continue;
		}
220

221
		if (strcasestr(test->desc, argv[i]))
222 223 224 225 226 227
			return true;
	}

	return false;
}

228
static int run_test(struct test *test, int subtest)
229 230
{
	int status, err = -1, child = fork();
231
	char sbuf[STRERR_BUFSIZE];
232 233

	if (child < 0) {
234 235
		pr_err("failed to fork test: %s\n",
			strerror_r(errno, sbuf, sizeof(sbuf)));
236 237 238 239 240
		return -1;
	}

	if (!child) {
		pr_debug("test child forked, pid %d\n", getpid());
241 242 243 244 245 246 247 248 249 250
		if (!verbose) {
			int nullfd = open("/dev/null", O_WRONLY);
			if (nullfd >= 0) {
				close(STDERR_FILENO);
				close(STDOUT_FILENO);

				dup2(nullfd, STDOUT_FILENO);
				dup2(STDOUT_FILENO, STDERR_FILENO);
				close(nullfd);
			}
251 252 253
		} else {
			signal(SIGSEGV, sighandler_dump_stack);
			signal(SIGFPE, sighandler_dump_stack);
254 255
		}

256
		err = test->func(subtest);
257 258 259 260 261 262
		exit(err);
	}

	wait(&status);

	if (WIFEXITED(status)) {
263
		err = (signed char)WEXITSTATUS(status);
264 265 266 267 268 269 270 271 272
		pr_debug("test child finished with %d\n", err);
	} else if (WIFSIGNALED(status)) {
		err = -1;
		pr_debug("test child interrupted\n");
	}

	return err;
}

273 274 275
#define for_each_test(j, t)	 				\
	for (j = 0; j < ARRAY_SIZE(tests); j++)	\
		for (t = &tests[j][0]; t->func; t++)
276

277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
static int test_and_print(struct test *t, bool force_skip, int subtest)
{
	int err;

	if (!force_skip) {
		pr_debug("\n--- start ---\n");
		err = run_test(t, subtest);
		pr_debug("---- end ----\n");
	} else {
		pr_debug("\n--- force skipped ---\n");
		err = TEST_SKIP;
	}

	if (!t->subtest.get_nr)
		pr_debug("%s:", t->desc);
	else
		pr_debug("%s subtest %d:", t->desc, subtest);

	switch (err) {
	case TEST_OK:
		pr_info(" Ok\n");
		break;
	case TEST_SKIP:
		color_fprintf(stderr, PERF_COLOR_YELLOW, " Skip\n");
		break;
	case TEST_FAIL:
	default:
		color_fprintf(stderr, PERF_COLOR_RED, " FAILED!\n");
		break;
	}

	return err;
}

311
static int __cmd_test(int argc, const char *argv[], struct intlist *skiplist)
312
{
313
	struct test *t;
314
	unsigned int j;
315
	int i = 0;
316
	int width = 0;
317

318
	for_each_test(j, t) {
319
		int len = strlen(t->desc);
320 321 322 323

		if (width < len)
			width = len;
	}
324

325
	for_each_test(j, t) {
326 327
		int curr = i++, err;

328
		if (!perf_test__matches(t, curr, argc, argv))
329 330
			continue;

331
		pr_info("%2d: %-*s:", i, width, t->desc);
332 333 334 335 336 337

		if (intlist__find(skiplist, i)) {
			color_fprintf(stderr, PERF_COLOR_YELLOW, " Skip (user override)\n");
			continue;
		}

338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
		if (!t->subtest.get_nr) {
			test_and_print(t, false, -1);
		} else {
			int subn = t->subtest.get_nr();
			/*
			 * minus 2 to align with normal testcases.
			 * For subtest we print additional '.x' in number.
			 * for example:
			 *
			 * 35: Test LLVM searching and compiling                        :
			 * 35.1: Basic BPF llvm compiling test                          : Ok
			 */
			int subw = width > 2 ? width - 2 : width;
			bool skip = false;
			int subi;

			if (subn <= 0) {
				color_fprintf(stderr, PERF_COLOR_YELLOW,
					      " Skip (not compiled in)\n");
				continue;
			}
			pr_info("\n");

			for (subi = 0; subi < subn; subi++) {
				int len = strlen(t->subtest.get_desc(subi));

				if (subw < len)
					subw = len;
			}

			for (subi = 0; subi < subn; subi++) {
				pr_info("%2d.%1d: %-*s:", i, subi + 1, subw,
					t->subtest.get_desc(subi));
				err = test_and_print(t, skip, subi);
				if (err != TEST_OK && t->subtest.skip_if_fail)
					skip = true;
			}
375
		}
376 377 378 379 380
	}

	return 0;
}

381 382
static int perf_test__list(int argc, const char **argv)
{
383
	unsigned int j;
384
	struct test *t;
385 386
	int i = 0;

387
	for_each_test(j, t) {
388
		if (argc > 1 && !strstr(t->desc, argv[1]))
389 390
			continue;

391
		pr_info("%2d: %s\n", ++i, t->desc);
392 393 394 395
	}

	return 0;
}
396

397
int cmd_test(int argc, const char **argv, const char *prefix __maybe_unused)
398
{
399
	const char *test_usage[] = {
400 401 402
	"perf test [<options>] [{list <test-name-fragment>|[<test-name-fragments>|<test-numbers>]}]",
	NULL,
	};
403
	const char *skip = NULL;
404
	const struct option test_options[] = {
405
	OPT_STRING('s', "skip", &skip, "tests", "tests to skip"),
406
	OPT_INCR('v', "verbose", &verbose,
407 408
		    "be more verbose (show symbol address, etc)"),
	OPT_END()
409
	};
410
	const char * const test_subcommands[] = { "list", NULL };
411
	struct intlist *skiplist = NULL;
412 413 414 415
        int ret = hists__init();

        if (ret < 0)
                return ret;
416

417
	argc = parse_options_subcommand(argc, argv, test_options, test_subcommands, test_usage, 0);
418 419
	if (argc >= 1 && !strcmp(argv[0], "list"))
		return perf_test__list(argc, argv);
420 421 422 423 424

	symbol_conf.priv_size = sizeof(int);
	symbol_conf.sort_by_name = true;
	symbol_conf.try_vmlinux_path = true;

425
	if (symbol__init(NULL) < 0)
426 427
		return -1;

428 429 430 431
	if (skip != NULL)
		skiplist = intlist__new(skip);

	return __cmd_test(argc, argv, skiplist);
432
}