1// SPDX-License-Identifier: GPL-2.0
2/*
3 * builtin-test.c
4 *
5 * Builtin regression testing command: ever growing number of sanity tests
6 */
7#include <fcntl.h>
8#include <errno.h>
9#include <unistd.h>
10#include <string.h>
11#include <stdlib.h>
12#include <sys/types.h>
13#include <dirent.h>
14#include <sys/wait.h>
15#include <sys/stat.h>
16#include "builtin.h"
17#include "hist.h"
18#include "intlist.h"
19#include "tests.h"
20#include "debug.h"
21#include "color.h"
22#include <subcmd/parse-options.h>
23#include "string2.h"
24#include "symbol.h"
25#include "util/rlimit.h"
26#include <linux/kernel.h>
27#include <linux/string.h>
28#include <subcmd/exec-cmd.h>
29
30static bool dont_fork;
31
32struct test __weak arch_tests[] = {
33	{
34		.func = NULL,
35	},
36};
37
38static struct test generic_tests[] = {
39	{
40		.desc = "vmlinux symtab matches kallsyms",
41		.func = test__vmlinux_matches_kallsyms,
42	},
43	{
44		.desc = "Detect openat syscall event",
45		.func = test__openat_syscall_event,
46	},
47	{
48		.desc = "Detect openat syscall event on all cpus",
49		.func = test__openat_syscall_event_on_all_cpus,
50	},
51	{
52		.desc = "Read samples using the mmap interface",
53		.func = test__basic_mmap,
54	},
55	{
56		.desc = "Test data source output",
57		.func = test__mem,
58	},
59	{
60		.desc = "Parse event definition strings",
61		.func = test__parse_events,
62	},
63	{
64		.desc = "Simple expression parser",
65		.func = test__expr,
66	},
67	{
68		.desc = "PERF_RECORD_* events & perf_sample fields",
69		.func = test__PERF_RECORD,
70	},
71	{
72		.desc = "Parse perf pmu format",
73		.func = test__pmu,
74	},
75	{
76		.desc = "PMU events",
77		.func = test__pmu_events,
78		.subtest = {
79			.skip_if_fail	= false,
80			.get_nr		= test__pmu_events_subtest_get_nr,
81			.get_desc	= test__pmu_events_subtest_get_desc,
82			.skip_reason	= test__pmu_events_subtest_skip_reason,
83		},
84
85	},
86	{
87		.desc = "DSO data read",
88		.func = test__dso_data,
89	},
90	{
91		.desc = "DSO data cache",
92		.func = test__dso_data_cache,
93	},
94	{
95		.desc = "DSO data reopen",
96		.func = test__dso_data_reopen,
97	},
98	{
99		.desc = "Roundtrip evsel->name",
100		.func = test__perf_evsel__roundtrip_name_test,
101	},
102	{
103		.desc = "Parse sched tracepoints fields",
104		.func = test__perf_evsel__tp_sched_test,
105	},
106	{
107		.desc = "syscalls:sys_enter_openat event fields",
108		.func = test__syscall_openat_tp_fields,
109	},
110	{
111		.desc = "Setup struct perf_event_attr",
112		.func = test__attr,
113	},
114	{
115		.desc = "Match and link multiple hists",
116		.func = test__hists_link,
117	},
118	{
119		.desc = "'import perf' in python",
120		.func = test__python_use,
121	},
122	{
123		.desc = "Breakpoint overflow signal handler",
124		.func = test__bp_signal,
125		.is_supported = test__bp_signal_is_supported,
126	},
127	{
128		.desc = "Breakpoint overflow sampling",
129		.func = test__bp_signal_overflow,
130		.is_supported = test__bp_signal_is_supported,
131	},
132	{
133		.desc = "Breakpoint accounting",
134		.func = test__bp_accounting,
135		.is_supported = test__bp_account_is_supported,
136	},
137	{
138		.desc = "Watchpoint",
139		.func = test__wp,
140		.is_supported = test__wp_is_supported,
141		.subtest = {
142			.skip_if_fail	= false,
143			.get_nr		= test__wp_subtest_get_nr,
144			.get_desc	= test__wp_subtest_get_desc,
145		},
146	},
147	{
148		.desc = "Number of exit events of a simple workload",
149		.func = test__task_exit,
150	},
151	{
152		.desc = "Software clock events period values",
153		.func = test__sw_clock_freq,
154	},
155	{
156		.desc = "Object code reading",
157		.func = test__code_reading,
158	},
159	{
160		.desc = "Sample parsing",
161		.func = test__sample_parsing,
162	},
163	{
164		.desc = "Use a dummy software event to keep tracking",
165		.func = test__keep_tracking,
166	},
167	{
168		.desc = "Parse with no sample_id_all bit set",
169		.func = test__parse_no_sample_id_all,
170	},
171	{
172		.desc = "Filter hist entries",
173		.func = test__hists_filter,
174	},
175	{
176		.desc = "Lookup mmap thread",
177		.func = test__mmap_thread_lookup,
178	},
179	{
180		.desc = "Share thread maps",
181		.func = test__thread_maps_share,
182	},
183	{
184		.desc = "Sort output of hist entries",
185		.func = test__hists_output,
186	},
187	{
188		.desc = "Cumulate child hist entries",
189		.func = test__hists_cumulate,
190	},
191	{
192		.desc = "Track with sched_switch",
193		.func = test__switch_tracking,
194	},
195	{
196		.desc = "Filter fds with revents mask in a fdarray",
197		.func = test__fdarray__filter,
198	},
199	{
200		.desc = "Add fd to a fdarray, making it autogrow",
201		.func = test__fdarray__add,
202	},
203	{
204		.desc = "kmod_path__parse",
205		.func = test__kmod_path__parse,
206	},
207	{
208		.desc = "Thread map",
209		.func = test__thread_map,
210	},
211	{
212		.desc = "LLVM search and compile",
213		.func = test__llvm,
214		.subtest = {
215			.skip_if_fail	= true,
216			.get_nr		= test__llvm_subtest_get_nr,
217			.get_desc	= test__llvm_subtest_get_desc,
218		},
219	},
220	{
221		.desc = "Session topology",
222		.func = test__session_topology,
223	},
224	{
225		.desc = "BPF filter",
226		.func = test__bpf,
227		.subtest = {
228			.skip_if_fail	= true,
229			.get_nr		= test__bpf_subtest_get_nr,
230			.get_desc	= test__bpf_subtest_get_desc,
231		},
232	},
233	{
234		.desc = "Synthesize thread map",
235		.func = test__thread_map_synthesize,
236	},
237	{
238		.desc = "Remove thread map",
239		.func = test__thread_map_remove,
240	},
241	{
242		.desc = "Synthesize cpu map",
243		.func = test__cpu_map_synthesize,
244	},
245	{
246		.desc = "Synthesize stat config",
247		.func = test__synthesize_stat_config,
248	},
249	{
250		.desc = "Synthesize stat",
251		.func = test__synthesize_stat,
252	},
253	{
254		.desc = "Synthesize stat round",
255		.func = test__synthesize_stat_round,
256	},
257	{
258		.desc = "Synthesize attr update",
259		.func = test__event_update,
260	},
261	{
262		.desc = "Event times",
263		.func = test__event_times,
264	},
265	{
266		.desc = "Read backward ring buffer",
267		.func = test__backward_ring_buffer,
268	},
269	{
270		.desc = "Print cpu map",
271		.func = test__cpu_map_print,
272	},
273	{
274		.desc = "Merge cpu map",
275		.func = test__cpu_map_merge,
276	},
277
278	{
279		.desc = "Probe SDT events",
280		.func = test__sdt_event,
281	},
282	{
283		.desc = "is_printable_array",
284		.func = test__is_printable_array,
285	},
286	{
287		.desc = "Print bitmap",
288		.func = test__bitmap_print,
289	},
290	{
291		.desc = "perf hooks",
292		.func = test__perf_hooks,
293	},
294	{
295		.desc = "builtin clang support",
296		.func = test__clang,
297		.subtest = {
298			.skip_if_fail	= true,
299			.get_nr		= test__clang_subtest_get_nr,
300			.get_desc	= test__clang_subtest_get_desc,
301		}
302	},
303	{
304		.desc = "unit_number__scnprintf",
305		.func = test__unit_number__scnprint,
306	},
307	{
308		.desc = "mem2node",
309		.func = test__mem2node,
310	},
311	{
312		.desc = "time utils",
313		.func = test__time_utils,
314	},
315	{
316		.desc = "Test jit_write_elf",
317		.func = test__jit_write_elf,
318	},
319	{
320		.desc = "Test libpfm4 support",
321		.func = test__pfm,
322		.subtest = {
323			.skip_if_fail	= true,
324			.get_nr		= test__pfm_subtest_get_nr,
325			.get_desc	= test__pfm_subtest_get_desc,
326		}
327	},
328	{
329		.desc = "Test api io",
330		.func = test__api_io,
331	},
332	{
333		.desc = "maps__merge_in",
334		.func = test__maps__merge_in,
335	},
336	{
337		.desc = "Demangle Java",
338		.func = test__demangle_java,
339	},
340	{
341		.desc = "Parse and process metrics",
342		.func = test__parse_metric,
343	},
344	{
345		.desc = "PE file support",
346		.func = test__pe_file_parsing,
347	},
348	{
349		.desc = "Event expansion for cgroups",
350		.func = test__expand_cgroup_events,
351	},
352	{
353		.func = NULL,
354	},
355};
356
357static struct test *tests[] = {
358	generic_tests,
359	arch_tests,
360};
361
362static bool perf_test__matches(const char *desc, int curr, int argc, const char *argv[])
363{
364	int i;
365
366	if (argc == 0)
367		return true;
368
369	for (i = 0; i < argc; ++i) {
370		char *end;
371		long nr = strtoul(argv[i], &end, 10);
372
373		if (*end == '\0') {
374			if (nr == curr + 1)
375				return true;
376			continue;
377		}
378
379		if (strcasestr(desc, argv[i]))
380			return true;
381	}
382
383	return false;
384}
385
386static int run_test(struct test *test, int subtest)
387{
388	int status, err = -1, child = dont_fork ? 0 : fork();
389	char sbuf[STRERR_BUFSIZE];
390
391	if (child < 0) {
392		pr_err("failed to fork test: %s\n",
393			str_error_r(errno, sbuf, sizeof(sbuf)));
394		return -1;
395	}
396
397	if (!child) {
398		if (!dont_fork) {
399			pr_debug("test child forked, pid %d\n", getpid());
400
401			if (verbose <= 0) {
402				int nullfd = open("/dev/null", O_WRONLY);
403
404				if (nullfd >= 0) {
405					close(STDERR_FILENO);
406					close(STDOUT_FILENO);
407
408					dup2(nullfd, STDOUT_FILENO);
409					dup2(STDOUT_FILENO, STDERR_FILENO);
410					close(nullfd);
411				}
412			} else {
413				signal(SIGSEGV, sighandler_dump_stack);
414				signal(SIGFPE, sighandler_dump_stack);
415			}
416		}
417
418		err = test->func(test, subtest);
419		if (!dont_fork)
420			exit(err);
421	}
422
423	if (!dont_fork) {
424		wait(&status);
425
426		if (WIFEXITED(status)) {
427			err = (signed char)WEXITSTATUS(status);
428			pr_debug("test child finished with %d\n", err);
429		} else if (WIFSIGNALED(status)) {
430			err = -1;
431			pr_debug("test child interrupted\n");
432		}
433	}
434
435	return err;
436}
437
438#define for_each_test(j, t)	 				\
439	for (j = 0; j < ARRAY_SIZE(tests); j++)	\
440		for (t = &tests[j][0]; t->func; t++)
441
442static int test_and_print(struct test *t, bool force_skip, int subtest)
443{
444	int err;
445
446	if (!force_skip) {
447		pr_debug("\n--- start ---\n");
448		err = run_test(t, subtest);
449		pr_debug("---- end ----\n");
450	} else {
451		pr_debug("\n--- force skipped ---\n");
452		err = TEST_SKIP;
453	}
454
455	if (!t->subtest.get_nr)
456		pr_debug("%s:", t->desc);
457	else
458		pr_debug("%s subtest %d:", t->desc, subtest + 1);
459
460	switch (err) {
461	case TEST_OK:
462		pr_info(" Ok\n");
463		break;
464	case TEST_SKIP: {
465		const char *skip_reason = NULL;
466		if (t->subtest.skip_reason)
467			skip_reason = t->subtest.skip_reason(subtest);
468		if (skip_reason)
469			color_fprintf(stderr, PERF_COLOR_YELLOW, " Skip (%s)\n", skip_reason);
470		else
471			color_fprintf(stderr, PERF_COLOR_YELLOW, " Skip\n");
472	}
473		break;
474	case TEST_FAIL:
475	default:
476		color_fprintf(stderr, PERF_COLOR_RED, " FAILED!\n");
477		break;
478	}
479
480	return err;
481}
482
483static const char *shell_test__description(char *description, size_t size,
484					   const char *path, const char *name)
485{
486	FILE *fp;
487	char filename[PATH_MAX];
488
489	path__join(filename, sizeof(filename), path, name);
490	fp = fopen(filename, "r");
491	if (!fp)
492		return NULL;
493
494	/* Skip shebang */
495	while (fgetc(fp) != '\n');
496
497	description = fgets(description, size, fp);
498	fclose(fp);
499
500	return description ? strim(description + 1) : NULL;
501}
502
503#define for_each_shell_test(dir, base, ent)	\
504	while ((ent = readdir(dir)) != NULL)	\
505		if (!is_directory(base, ent) && ent->d_name[0] != '.')
506
507static const char *shell_tests__dir(char *path, size_t size)
508{
509	const char *devel_dirs[] = { "./tools/perf/tests", "./tests", };
510        char *exec_path;
511	unsigned int i;
512
513	for (i = 0; i < ARRAY_SIZE(devel_dirs); ++i) {
514		struct stat st;
515		if (!lstat(devel_dirs[i], &st)) {
516			scnprintf(path, size, "%s/shell", devel_dirs[i]);
517			if (!lstat(devel_dirs[i], &st))
518				return path;
519		}
520	}
521
522        /* Then installed path. */
523        exec_path = get_argv_exec_path();
524        scnprintf(path, size, "%s/tests/shell", exec_path);
525	free(exec_path);
526	return path;
527}
528
529static int shell_tests__max_desc_width(void)
530{
531	DIR *dir;
532	struct dirent *ent;
533	char path_dir[PATH_MAX];
534	const char *path = shell_tests__dir(path_dir, sizeof(path_dir));
535	int width = 0;
536
537	if (path == NULL)
538		return -1;
539
540	dir = opendir(path);
541	if (!dir)
542		return -1;
543
544	for_each_shell_test(dir, path, ent) {
545		char bf[256];
546		const char *desc = shell_test__description(bf, sizeof(bf), path, ent->d_name);
547
548		if (desc) {
549			int len = strlen(desc);
550
551			if (width < len)
552				width = len;
553		}
554	}
555
556	closedir(dir);
557	return width;
558}
559
560struct shell_test {
561	const char *dir;
562	const char *file;
563};
564
565static int shell_test__run(struct test *test, int subdir __maybe_unused)
566{
567	int err;
568	char script[PATH_MAX];
569	struct shell_test *st = test->priv;
570
571	path__join(script, sizeof(script), st->dir, st->file);
572
573	err = system(script);
574	if (!err)
575		return TEST_OK;
576
577	return WEXITSTATUS(err) == 2 ? TEST_SKIP : TEST_FAIL;
578}
579
580static int run_shell_tests(int argc, const char *argv[], int i, int width)
581{
582	DIR *dir;
583	struct dirent *ent;
584	char path_dir[PATH_MAX];
585	struct shell_test st = {
586		.dir = shell_tests__dir(path_dir, sizeof(path_dir)),
587	};
588
589	if (st.dir == NULL)
590		return -1;
591
592	dir = opendir(st.dir);
593	if (!dir) {
594		pr_err("failed to open shell test directory: %s\n",
595			st.dir);
596		return -1;
597	}
598
599	for_each_shell_test(dir, st.dir, ent) {
600		int curr = i++;
601		char desc[256];
602		struct test test = {
603			.desc = shell_test__description(desc, sizeof(desc), st.dir, ent->d_name),
604			.func = shell_test__run,
605			.priv = &st,
606		};
607
608		if (!perf_test__matches(test.desc, curr, argc, argv))
609			continue;
610
611		st.file = ent->d_name;
612		pr_info("%2d: %-*s:", i, width, test.desc);
613		test_and_print(&test, false, -1);
614	}
615
616	closedir(dir);
617	return 0;
618}
619
620static int __cmd_test(int argc, const char *argv[], struct intlist *skiplist)
621{
622	struct test *t;
623	unsigned int j;
624	int i = 0;
625	int width = shell_tests__max_desc_width();
626
627	for_each_test(j, t) {
628		int len = strlen(t->desc);
629
630		if (width < len)
631			width = len;
632	}
633
634	for_each_test(j, t) {
635		int curr = i++, err;
636		int subi;
637
638		if (!perf_test__matches(t->desc, curr, argc, argv)) {
639			bool skip = true;
640			int subn;
641
642			if (!t->subtest.get_nr)
643				continue;
644
645			subn = t->subtest.get_nr();
646
647			for (subi = 0; subi < subn; subi++) {
648				if (perf_test__matches(t->subtest.get_desc(subi), curr, argc, argv))
649					skip = false;
650			}
651
652			if (skip)
653				continue;
654		}
655
656		if (t->is_supported && !t->is_supported()) {
657			pr_debug("%2d: %-*s: Disabled\n", i, width, t->desc);
658			continue;
659		}
660
661		pr_info("%2d: %-*s:", i, width, t->desc);
662
663		if (intlist__find(skiplist, i)) {
664			color_fprintf(stderr, PERF_COLOR_YELLOW, " Skip (user override)\n");
665			continue;
666		}
667
668		if (!t->subtest.get_nr) {
669			test_and_print(t, false, -1);
670		} else {
671			int subn = t->subtest.get_nr();
672			/*
673			 * minus 2 to align with normal testcases.
674			 * For subtest we print additional '.x' in number.
675			 * for example:
676			 *
677			 * 35: Test LLVM searching and compiling                        :
678			 * 35.1: Basic BPF llvm compiling test                          : Ok
679			 */
680			int subw = width > 2 ? width - 2 : width;
681			bool skip = false;
682
683			if (subn <= 0) {
684				color_fprintf(stderr, PERF_COLOR_YELLOW,
685					      " Skip (not compiled in)\n");
686				continue;
687			}
688			pr_info("\n");
689
690			for (subi = 0; subi < subn; subi++) {
691				int len = strlen(t->subtest.get_desc(subi));
692
693				if (subw < len)
694					subw = len;
695			}
696
697			for (subi = 0; subi < subn; subi++) {
698				if (!perf_test__matches(t->subtest.get_desc(subi), curr, argc, argv))
699					continue;
700
701				pr_info("%2d.%1d: %-*s:", i, subi + 1, subw,
702					t->subtest.get_desc(subi));
703				err = test_and_print(t, skip, subi);
704				if (err != TEST_OK && t->subtest.skip_if_fail)
705					skip = true;
706			}
707		}
708	}
709
710	return run_shell_tests(argc, argv, i, width);
711}
712
713static int perf_test__list_shell(int argc, const char **argv, int i)
714{
715	DIR *dir;
716	struct dirent *ent;
717	char path_dir[PATH_MAX];
718	const char *path = shell_tests__dir(path_dir, sizeof(path_dir));
719
720	if (path == NULL)
721		return -1;
722
723	dir = opendir(path);
724	if (!dir)
725		return -1;
726
727	for_each_shell_test(dir, path, ent) {
728		int curr = i++;
729		char bf[256];
730		struct test t = {
731			.desc = shell_test__description(bf, sizeof(bf), path, ent->d_name),
732		};
733
734		if (!perf_test__matches(t.desc, curr, argc, argv))
735			continue;
736
737		pr_info("%2d: %s\n", i, t.desc);
738	}
739
740	closedir(dir);
741	return 0;
742}
743
744static int perf_test__list(int argc, const char **argv)
745{
746	unsigned int j;
747	struct test *t;
748	int i = 0;
749
750	for_each_test(j, t) {
751		int curr = i++;
752
753		if (!perf_test__matches(t->desc, curr, argc, argv) ||
754		    (t->is_supported && !t->is_supported()))
755			continue;
756
757		pr_info("%2d: %s\n", i, t->desc);
758
759		if (t->subtest.get_nr) {
760			int subn = t->subtest.get_nr();
761			int subi;
762
763			for (subi = 0; subi < subn; subi++)
764				pr_info("%2d:%1d: %s\n", i, subi + 1,
765					t->subtest.get_desc(subi));
766		}
767	}
768
769	perf_test__list_shell(argc, argv, i);
770
771	return 0;
772}
773
774int cmd_test(int argc, const char **argv)
775{
776	const char *test_usage[] = {
777	"perf test [<options>] [{list <test-name-fragment>|[<test-name-fragments>|<test-numbers>]}]",
778	NULL,
779	};
780	const char *skip = NULL;
781	const struct option test_options[] = {
782	OPT_STRING('s', "skip", &skip, "tests", "tests to skip"),
783	OPT_INCR('v', "verbose", &verbose,
784		    "be more verbose (show symbol address, etc)"),
785	OPT_BOOLEAN('F', "dont-fork", &dont_fork,
786		    "Do not fork for testcase"),
787	OPT_END()
788	};
789	const char * const test_subcommands[] = { "list", NULL };
790	struct intlist *skiplist = NULL;
791        int ret = hists__init();
792
793        if (ret < 0)
794                return ret;
795
796	/* Unbuffered output */
797	setvbuf(stdout, NULL, _IONBF, 0);
798
799	argc = parse_options_subcommand(argc, argv, test_options, test_subcommands, test_usage, 0);
800	if (argc >= 1 && !strcmp(argv[0], "list"))
801		return perf_test__list(argc - 1, argv + 1);
802
803	symbol_conf.priv_size = sizeof(int);
804	symbol_conf.sort_by_name = true;
805	symbol_conf.try_vmlinux_path = true;
806
807	if (symbol__init(NULL) < 0)
808		return -1;
809
810	if (skip != NULL)
811		skiplist = intlist__new(skip);
812	/*
813	 * Tests that create BPF maps, for instance, need more than the 64K
814	 * default:
815	 */
816	rlimit__bump_memlock();
817
818	return __cmd_test(argc, argv, skiplist);
819}
820