1 | /* |
2 | * perf.c |
3 | * |
4 | * Performance analysis utility. |
5 | * |
6 | * This is the main hub from which the sub-commands (perf stat, |
7 | * perf top, perf record, perf report, etc.) are started. |
8 | */ |
9 | #include "builtin.h" |
10 | #include "perf.h" |
11 | |
12 | #include "util/build-id.h" |
13 | #include "util/cache.h" |
14 | #include "util/env.h" |
15 | #include <internal/lib.h> // page_size |
16 | #include <subcmd/exec-cmd.h> |
17 | #include "util/config.h" |
18 | #include <subcmd/run-command.h> |
19 | #include "util/parse-events.h" |
20 | #include <subcmd/parse-options.h> |
21 | #include "util/debug.h" |
22 | #include "util/event.h" |
23 | #include "util/util.h" // usage() |
24 | #include "ui/ui.h" |
25 | #include "perf-sys.h" |
26 | #include <api/fs/fs.h> |
27 | #include <api/fs/tracing_path.h> |
28 | #include <perf/core.h> |
29 | #include <errno.h> |
30 | #include <pthread.h> |
31 | #include <signal.h> |
32 | #include <stdlib.h> |
33 | #include <time.h> |
34 | #include <sys/types.h> |
35 | #include <sys/stat.h> |
36 | #include <unistd.h> |
37 | #include <linux/kernel.h> |
38 | #include <linux/string.h> |
39 | #include <linux/zalloc.h> |
40 | |
41 | static int = -1; |
42 | |
43 | struct cmd_struct { |
44 | const char *cmd; |
45 | int (*fn)(int, const char **); |
46 | int option; |
47 | }; |
48 | |
49 | static struct cmd_struct commands[] = { |
50 | { "archive" , NULL, 0 }, |
51 | { "buildid-cache" , cmd_buildid_cache, 0 }, |
52 | { "buildid-list" , cmd_buildid_list, 0 }, |
53 | { "config" , cmd_config, 0 }, |
54 | { "c2c" , cmd_c2c, 0 }, |
55 | { "diff" , cmd_diff, 0 }, |
56 | { "evlist" , cmd_evlist, 0 }, |
57 | { "help" , cmd_help, 0 }, |
58 | { "iostat" , NULL, 0 }, |
59 | { "kallsyms" , cmd_kallsyms, 0 }, |
60 | { "list" , cmd_list, 0 }, |
61 | { "record" , cmd_record, 0 }, |
62 | { "report" , cmd_report, 0 }, |
63 | { "bench" , cmd_bench, 0 }, |
64 | { "stat" , cmd_stat, 0 }, |
65 | #ifdef HAVE_LIBTRACEEVENT |
66 | { "timechart" , cmd_timechart, 0 }, |
67 | #endif |
68 | { "top" , cmd_top, 0 }, |
69 | { "annotate" , cmd_annotate, 0 }, |
70 | { "version" , cmd_version, 0 }, |
71 | { "script" , cmd_script, 0 }, |
72 | #ifdef HAVE_LIBTRACEEVENT |
73 | { "sched" , cmd_sched, 0 }, |
74 | #endif |
75 | #ifdef HAVE_LIBELF_SUPPORT |
76 | { "probe" , cmd_probe, 0 }, |
77 | #endif |
78 | #ifdef HAVE_LIBTRACEEVENT |
79 | { "kmem" , cmd_kmem, 0 }, |
80 | { "lock" , cmd_lock, 0 }, |
81 | #endif |
82 | { "kvm" , cmd_kvm, 0 }, |
83 | { "test" , cmd_test, 0 }, |
84 | #if defined(HAVE_LIBTRACEEVENT) && (defined(HAVE_LIBAUDIT_SUPPORT) || defined(HAVE_SYSCALL_TABLE_SUPPORT)) |
85 | { "trace" , cmd_trace, 0 }, |
86 | #endif |
87 | { "inject" , cmd_inject, 0 }, |
88 | { "mem" , cmd_mem, 0 }, |
89 | { "data" , cmd_data, 0 }, |
90 | { "ftrace" , cmd_ftrace, 0 }, |
91 | { "daemon" , cmd_daemon, 0 }, |
92 | #ifdef HAVE_LIBTRACEEVENT |
93 | { "kwork" , cmd_kwork, 0 }, |
94 | #endif |
95 | }; |
96 | |
97 | struct { |
98 | const char *; |
99 | int ; |
100 | }; |
101 | |
102 | static bool same_cmd_with_prefix(const char *var, struct pager_config *c, |
103 | const char *) |
104 | { |
105 | return (strstarts(str: var, prefix: header) && !strcmp(var + strlen(header), c->cmd)); |
106 | } |
107 | |
108 | static int pager_command_config(const char *var, const char *value, void *data) |
109 | { |
110 | struct pager_config *c = data; |
111 | if (same_cmd_with_prefix(var, c, header: "pager." )) |
112 | c->val = perf_config_bool(var, value); |
113 | return 0; |
114 | } |
115 | |
116 | /* returns 0 for "no pager", 1 for "use pager", and -1 for "not specified" */ |
117 | static int (const char *cmd) |
118 | { |
119 | int err; |
120 | struct pager_config c; |
121 | c.cmd = cmd; |
122 | c.val = -1; |
123 | err = perf_config(fn: pager_command_config, &c); |
124 | return err ?: c.val; |
125 | } |
126 | |
127 | static int browser_command_config(const char *var, const char *value, void *data) |
128 | { |
129 | struct pager_config *c = data; |
130 | if (same_cmd_with_prefix(var, c, header: "tui." )) |
131 | c->val = perf_config_bool(var, value); |
132 | if (same_cmd_with_prefix(var, c, header: "gtk." )) |
133 | c->val = perf_config_bool(var, value) ? 2 : 0; |
134 | return 0; |
135 | } |
136 | |
137 | /* |
138 | * returns 0 for "no tui", 1 for "use tui", 2 for "use gtk", |
139 | * and -1 for "not specified" |
140 | */ |
141 | static int check_browser_config(const char *cmd) |
142 | { |
143 | int err; |
144 | struct pager_config c; |
145 | c.cmd = cmd; |
146 | c.val = -1; |
147 | err = perf_config(fn: browser_command_config, &c); |
148 | return err ?: c.val; |
149 | } |
150 | |
151 | static void (void) |
152 | { |
153 | switch (use_pager) { |
154 | case 0: |
155 | setenv(PERF_PAGER_ENVIRONMENT, "cat" , 1); |
156 | break; |
157 | case 1: |
158 | /* setup_pager(); */ |
159 | break; |
160 | default: |
161 | break; |
162 | } |
163 | } |
164 | |
165 | struct option options[] = { |
166 | OPT_ARGUMENT("help" , "help" ), |
167 | OPT_ARGUMENT("version" , "version" ), |
168 | OPT_ARGUMENT("exec-path" , "exec-path" ), |
169 | OPT_ARGUMENT("html-path" , "html-path" ), |
170 | OPT_ARGUMENT("paginate" , "paginate" ), |
171 | OPT_ARGUMENT("no-pager" , "no-pager" ), |
172 | OPT_ARGUMENT("debugfs-dir" , "debugfs-dir" ), |
173 | OPT_ARGUMENT("buildid-dir" , "buildid-dir" ), |
174 | OPT_ARGUMENT("list-cmds" , "list-cmds" ), |
175 | OPT_ARGUMENT("list-opts" , "list-opts" ), |
176 | OPT_ARGUMENT("debug" , "debug" ), |
177 | OPT_END() |
178 | }; |
179 | |
180 | static int handle_options(const char ***argv, int *argc, int *envchanged) |
181 | { |
182 | int handled = 0; |
183 | |
184 | while (*argc > 0) { |
185 | const char *cmd = (*argv)[0]; |
186 | if (cmd[0] != '-') |
187 | break; |
188 | |
189 | /* |
190 | * For legacy reasons, the "version" and "help" |
191 | * commands can be written with "--" prepended |
192 | * to make them look like flags. |
193 | */ |
194 | if (!strcmp(cmd, "--help" ) || !strcmp(cmd, "--version" )) |
195 | break; |
196 | |
197 | /* |
198 | * Shortcut for '-h' and '-v' options to invoke help |
199 | * and version command. |
200 | */ |
201 | if (!strcmp(cmd, "-h" )) { |
202 | (*argv)[0] = "--help" ; |
203 | break; |
204 | } |
205 | |
206 | if (!strcmp(cmd, "-v" )) { |
207 | (*argv)[0] = "--version" ; |
208 | break; |
209 | } |
210 | |
211 | if (!strcmp(cmd, "-vv" )) { |
212 | (*argv)[0] = "version" ; |
213 | verbose = 1; |
214 | break; |
215 | } |
216 | |
217 | /* |
218 | * Check remaining flags. |
219 | */ |
220 | if (strstarts(str: cmd, CMD_EXEC_PATH)) { |
221 | cmd += strlen(CMD_EXEC_PATH); |
222 | if (*cmd == '=') |
223 | set_argv_exec_path(cmd + 1); |
224 | else { |
225 | puts(get_argv_exec_path()); |
226 | exit(0); |
227 | } |
228 | } else if (!strcmp(cmd, "--html-path" )) { |
229 | puts(system_path(PERF_HTML_PATH)); |
230 | exit(0); |
231 | } else if (!strcmp(cmd, "-p" ) || !strcmp(cmd, "--paginate" )) { |
232 | use_pager = 1; |
233 | } else if (!strcmp(cmd, "--no-pager" )) { |
234 | use_pager = 0; |
235 | if (envchanged) |
236 | *envchanged = 1; |
237 | } else if (!strcmp(cmd, "--debugfs-dir" )) { |
238 | if (*argc < 2) { |
239 | fprintf(stderr, "No directory given for --debugfs-dir.\n" ); |
240 | usage(err: perf_usage_string); |
241 | } |
242 | tracing_path_set((*argv)[1]); |
243 | if (envchanged) |
244 | *envchanged = 1; |
245 | (*argv)++; |
246 | (*argc)--; |
247 | } else if (!strcmp(cmd, "--buildid-dir" )) { |
248 | if (*argc < 2) { |
249 | fprintf(stderr, "No directory given for --buildid-dir.\n" ); |
250 | usage(err: perf_usage_string); |
251 | } |
252 | set_buildid_dir((*argv)[1]); |
253 | if (envchanged) |
254 | *envchanged = 1; |
255 | (*argv)++; |
256 | (*argc)--; |
257 | } else if (strstarts(str: cmd, CMD_DEBUGFS_DIR)) { |
258 | tracing_path_set(cmd + strlen(CMD_DEBUGFS_DIR)); |
259 | fprintf(stderr, "dir: %s\n" , tracing_path_mount()); |
260 | if (envchanged) |
261 | *envchanged = 1; |
262 | } else if (!strcmp(cmd, "--list-cmds" )) { |
263 | unsigned int i; |
264 | |
265 | for (i = 0; i < ARRAY_SIZE(commands); i++) { |
266 | struct cmd_struct *p = commands+i; |
267 | printf("%s " , p->cmd); |
268 | } |
269 | putchar('\n'); |
270 | exit(0); |
271 | } else if (!strcmp(cmd, "--list-opts" )) { |
272 | unsigned int i; |
273 | |
274 | for (i = 0; i < ARRAY_SIZE(options)-1; i++) { |
275 | struct option *p = options+i; |
276 | printf("--%s " , p->long_name); |
277 | } |
278 | putchar('\n'); |
279 | exit(0); |
280 | } else if (!strcmp(cmd, "--debug" )) { |
281 | if (*argc < 2) { |
282 | fprintf(stderr, "No variable specified for --debug.\n" ); |
283 | usage(err: perf_usage_string); |
284 | } |
285 | if (perf_debug_option(str: (*argv)[1])) |
286 | usage(err: perf_usage_string); |
287 | |
288 | (*argv)++; |
289 | (*argc)--; |
290 | } else { |
291 | fprintf(stderr, "Unknown option: %s\n" , cmd); |
292 | usage(err: perf_usage_string); |
293 | } |
294 | |
295 | (*argv)++; |
296 | (*argc)--; |
297 | handled++; |
298 | } |
299 | return handled; |
300 | } |
301 | |
302 | #define RUN_SETUP (1<<0) |
303 | #define (1<<1) |
304 | |
305 | static int run_builtin(struct cmd_struct *p, int argc, const char **argv) |
306 | { |
307 | int status; |
308 | struct stat st; |
309 | char sbuf[STRERR_BUFSIZE]; |
310 | |
311 | if (use_browser == -1) |
312 | use_browser = check_browser_config(cmd: p->cmd); |
313 | |
314 | if (use_pager == -1 && p->option & RUN_SETUP) |
315 | use_pager = check_pager_config(cmd: p->cmd); |
316 | if (use_pager == -1 && p->option & USE_PAGER) |
317 | use_pager = 1; |
318 | commit_pager_choice(); |
319 | |
320 | perf_env__init(env: &perf_env); |
321 | perf_env__set_cmdline(env: &perf_env, argc, argv); |
322 | status = p->fn(argc, argv); |
323 | perf_config__exit(); |
324 | exit_browser(wait_for_ok: status); |
325 | perf_env__exit(env: &perf_env); |
326 | |
327 | if (status) |
328 | return status & 0xff; |
329 | |
330 | /* Somebody closed stdout? */ |
331 | if (fstat(fileno(stdout), &st)) |
332 | return 0; |
333 | /* Ignore write errors for pipes and sockets.. */ |
334 | if (S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode)) |
335 | return 0; |
336 | |
337 | status = 1; |
338 | /* Check for ENOSPC and EIO errors.. */ |
339 | if (fflush(stdout)) { |
340 | fprintf(stderr, "write failure on standard output: %s" , |
341 | str_error_r(errno, sbuf, sizeof(sbuf))); |
342 | goto out; |
343 | } |
344 | if (ferror(stdout)) { |
345 | fprintf(stderr, "unknown write failure on standard output" ); |
346 | goto out; |
347 | } |
348 | if (fclose(stdout)) { |
349 | fprintf(stderr, "close failed on standard output: %s" , |
350 | str_error_r(errno, sbuf, sizeof(sbuf))); |
351 | goto out; |
352 | } |
353 | status = 0; |
354 | out: |
355 | return status; |
356 | } |
357 | |
358 | static void handle_internal_command(int argc, const char **argv) |
359 | { |
360 | const char *cmd = argv[0]; |
361 | unsigned int i; |
362 | |
363 | /* Turn "perf cmd --help" into "perf help cmd" */ |
364 | if (argc > 1 && !strcmp(argv[1], "--help" )) { |
365 | argv[1] = argv[0]; |
366 | argv[0] = cmd = "help" ; |
367 | } |
368 | |
369 | for (i = 0; i < ARRAY_SIZE(commands); i++) { |
370 | struct cmd_struct *p = commands+i; |
371 | if (p->fn == NULL) |
372 | continue; |
373 | if (strcmp(p->cmd, cmd)) |
374 | continue; |
375 | exit(run_builtin(p, argc, argv)); |
376 | } |
377 | } |
378 | |
379 | static void execv_dashed_external(const char **argv) |
380 | { |
381 | char *cmd; |
382 | const char *tmp; |
383 | int status; |
384 | |
385 | if (asprintf(&cmd, "perf-%s" , argv[0]) < 0) |
386 | goto do_die; |
387 | |
388 | /* |
389 | * argv[0] must be the perf command, but the argv array |
390 | * belongs to the caller, and may be reused in |
391 | * subsequent loop iterations. Save argv[0] and |
392 | * restore it on error. |
393 | */ |
394 | tmp = argv[0]; |
395 | argv[0] = cmd; |
396 | |
397 | /* |
398 | * if we fail because the command is not found, it is |
399 | * OK to return. Otherwise, we just pass along the status code. |
400 | */ |
401 | status = run_command_v_opt(argv, 0); |
402 | if (status != -ERR_RUN_COMMAND_EXEC) { |
403 | if (IS_RUN_COMMAND_ERR(status)) { |
404 | do_die: |
405 | pr_err("FATAL: unable to run '%s'" , argv[0]); |
406 | status = -128; |
407 | } |
408 | exit(-status); |
409 | } |
410 | errno = ENOENT; /* as if we called execvp */ |
411 | |
412 | argv[0] = tmp; |
413 | zfree(&cmd); |
414 | } |
415 | |
416 | static int run_argv(int *argcp, const char ***argv) |
417 | { |
418 | /* See if it's an internal command */ |
419 | handle_internal_command(argc: *argcp, argv: *argv); |
420 | |
421 | /* .. then try the external ones */ |
422 | execv_dashed_external(argv: *argv); |
423 | return 0; |
424 | } |
425 | |
426 | static int libperf_print(enum libperf_print_level level, |
427 | const char *fmt, va_list ap) |
428 | { |
429 | return veprintf(level: level, var: verbose, fmt, args: ap); |
430 | } |
431 | |
432 | int main(int argc, const char **argv) |
433 | { |
434 | int err; |
435 | const char *cmd; |
436 | char sbuf[STRERR_BUFSIZE]; |
437 | |
438 | perf_debug_setup(); |
439 | |
440 | /* libsubcmd init */ |
441 | exec_cmd_init("perf" , PREFIX, PERF_EXEC_PATH, EXEC_PATH_ENVIRONMENT); |
442 | pager_init(PERF_PAGER_ENVIRONMENT); |
443 | |
444 | libperf_init(libperf_print); |
445 | |
446 | cmd = extract_argv0_path(argv[0]); |
447 | if (!cmd) |
448 | cmd = "perf-help" ; |
449 | |
450 | srandom(time(NULL)); |
451 | |
452 | /* Setting $PERF_CONFIG makes perf read _only_ the given config file. */ |
453 | config_exclusive_filename = getenv("PERF_CONFIG" ); |
454 | |
455 | err = perf_config(fn: perf_default_config, NULL); |
456 | if (err) |
457 | return err; |
458 | set_buildid_dir(NULL); |
459 | |
460 | /* |
461 | * "perf-xxxx" is the same as "perf xxxx", but we obviously: |
462 | * |
463 | * - cannot take flags in between the "perf" and the "xxxx". |
464 | * - cannot execute it externally (since it would just do |
465 | * the same thing over again) |
466 | * |
467 | * So we just directly call the internal command handler. If that one |
468 | * fails to handle this, then maybe we just run a renamed perf binary |
469 | * that contains a dash in its name. To handle this scenario, we just |
470 | * fall through and ignore the "xxxx" part of the command string. |
471 | */ |
472 | if (strstarts(str: cmd, prefix: "perf-" )) { |
473 | cmd += 5; |
474 | argv[0] = cmd; |
475 | handle_internal_command(argc, argv); |
476 | /* |
477 | * If the command is handled, the above function does not |
478 | * return undo changes and fall through in such a case. |
479 | */ |
480 | cmd -= 5; |
481 | argv[0] = cmd; |
482 | } |
483 | if (strstarts(str: cmd, prefix: "trace" )) { |
484 | #ifndef HAVE_LIBTRACEEVENT |
485 | fprintf(stderr, |
486 | "trace command not available: missing libtraceevent devel package at build time.\n" ); |
487 | goto out; |
488 | #elif !defined(HAVE_LIBAUDIT_SUPPORT) && !defined(HAVE_SYSCALL_TABLE_SUPPORT) |
489 | fprintf(stderr, |
490 | "trace command not available: missing audit-libs devel package at build time.\n" ); |
491 | goto out; |
492 | #else |
493 | setup_path(); |
494 | argv[0] = "trace" ; |
495 | return cmd_trace(argc, argv); |
496 | #endif |
497 | } |
498 | /* Look for flags.. */ |
499 | argv++; |
500 | argc--; |
501 | handle_options(argv: &argv, argc: &argc, NULL); |
502 | commit_pager_choice(); |
503 | |
504 | if (argc > 0) { |
505 | if (strstarts(str: argv[0], prefix: "--" )) |
506 | argv[0] += 2; |
507 | } else { |
508 | /* The user didn't specify a command; give them help */ |
509 | printf("\n usage: %s\n\n" , perf_usage_string); |
510 | list_common_cmds_help(); |
511 | printf("\n %s\n\n" , perf_more_info_string); |
512 | goto out; |
513 | } |
514 | cmd = argv[0]; |
515 | |
516 | test_attr__init(); |
517 | |
518 | /* |
519 | * We use PATH to find perf commands, but we prepend some higher |
520 | * precedence paths: the "--exec-path" option, the PERF_EXEC_PATH |
521 | * environment, and the $(perfexecdir) from the Makefile at build |
522 | * time. |
523 | */ |
524 | setup_path(); |
525 | /* |
526 | * Block SIGWINCH notifications so that the thread that wants it can |
527 | * unblock and get syscalls like select interrupted instead of waiting |
528 | * forever while the signal goes to some other non interested thread. |
529 | */ |
530 | pthread__block_sigwinch(); |
531 | |
532 | while (1) { |
533 | static int done_help; |
534 | |
535 | run_argv(argcp: &argc, argv: &argv); |
536 | |
537 | if (errno != ENOENT) |
538 | break; |
539 | |
540 | if (!done_help) { |
541 | cmd = argv[0] = help_unknown_cmd(cmd); |
542 | done_help = 1; |
543 | } else |
544 | break; |
545 | } |
546 | |
547 | fprintf(stderr, "Failed to run command '%s': %s\n" , |
548 | cmd, str_error_r(errno, sbuf, sizeof(sbuf))); |
549 | out: |
550 | return 1; |
551 | } |
552 | |