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