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