perf tools: Add x86 RDPMC, RDTSC test
[~shefty/rdma-dev.git] / tools / perf / perf.c
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
11 #include "util/exec_cmd.h"
12 #include "util/cache.h"
13 #include "util/quote.h"
14 #include "util/run-command.h"
15 #include "util/parse-events.h"
16 #include "util/debugfs.h"
17
18 const char perf_usage_string[] =
19         "perf [--version] [--help] COMMAND [ARGS]";
20
21 const char perf_more_info_string[] =
22         "See 'perf help COMMAND' for more information on a specific command.";
23
24 int use_browser = -1;
25 static int use_pager = -1;
26
27 struct pager_config {
28         const char *cmd;
29         int val;
30 };
31
32 static int pager_command_config(const char *var, const char *value, void *data)
33 {
34         struct pager_config *c = data;
35         if (!prefixcmp(var, "pager.") && !strcmp(var + 6, c->cmd))
36                 c->val = perf_config_bool(var, value);
37         return 0;
38 }
39
40 /* returns 0 for "no pager", 1 for "use pager", and -1 for "not specified" */
41 int check_pager_config(const char *cmd)
42 {
43         struct pager_config c;
44         c.cmd = cmd;
45         c.val = -1;
46         perf_config(pager_command_config, &c);
47         return c.val;
48 }
49
50 static int tui_command_config(const char *var, const char *value, void *data)
51 {
52         struct pager_config *c = data;
53         if (!prefixcmp(var, "tui.") && !strcmp(var + 4, c->cmd))
54                 c->val = perf_config_bool(var, value);
55         return 0;
56 }
57
58 /* returns 0 for "no tui", 1 for "use tui", and -1 for "not specified" */
59 static int check_tui_config(const char *cmd)
60 {
61         struct pager_config c;
62         c.cmd = cmd;
63         c.val = -1;
64         perf_config(tui_command_config, &c);
65         return c.val;
66 }
67
68 static void commit_pager_choice(void)
69 {
70         switch (use_pager) {
71         case 0:
72                 setenv("PERF_PAGER", "cat", 1);
73                 break;
74         case 1:
75                 /* setup_pager(); */
76                 break;
77         default:
78                 break;
79         }
80 }
81
82 static int handle_options(const char ***argv, int *argc, int *envchanged)
83 {
84         int handled = 0;
85
86         while (*argc > 0) {
87                 const char *cmd = (*argv)[0];
88                 if (cmd[0] != '-')
89                         break;
90
91                 /*
92                  * For legacy reasons, the "version" and "help"
93                  * commands can be written with "--" prepended
94                  * to make them look like flags.
95                  */
96                 if (!strcmp(cmd, "--help") || !strcmp(cmd, "--version"))
97                         break;
98
99                 /*
100                  * Check remaining flags.
101                  */
102                 if (!prefixcmp(cmd, CMD_EXEC_PATH)) {
103                         cmd += strlen(CMD_EXEC_PATH);
104                         if (*cmd == '=')
105                                 perf_set_argv_exec_path(cmd + 1);
106                         else {
107                                 puts(perf_exec_path());
108                                 exit(0);
109                         }
110                 } else if (!strcmp(cmd, "--html-path")) {
111                         puts(system_path(PERF_HTML_PATH));
112                         exit(0);
113                 } else if (!strcmp(cmd, "-p") || !strcmp(cmd, "--paginate")) {
114                         use_pager = 1;
115                 } else if (!strcmp(cmd, "--no-pager")) {
116                         use_pager = 0;
117                         if (envchanged)
118                                 *envchanged = 1;
119                 } else if (!strcmp(cmd, "--perf-dir")) {
120                         if (*argc < 2) {
121                                 fprintf(stderr, "No directory given for --perf-dir.\n");
122                                 usage(perf_usage_string);
123                         }
124                         setenv(PERF_DIR_ENVIRONMENT, (*argv)[1], 1);
125                         if (envchanged)
126                                 *envchanged = 1;
127                         (*argv)++;
128                         (*argc)--;
129                         handled++;
130                 } else if (!prefixcmp(cmd, CMD_PERF_DIR)) {
131                         setenv(PERF_DIR_ENVIRONMENT, cmd + strlen(CMD_PERF_DIR), 1);
132                         if (envchanged)
133                                 *envchanged = 1;
134                 } else if (!strcmp(cmd, "--work-tree")) {
135                         if (*argc < 2) {
136                                 fprintf(stderr, "No directory given for --work-tree.\n");
137                                 usage(perf_usage_string);
138                         }
139                         setenv(PERF_WORK_TREE_ENVIRONMENT, (*argv)[1], 1);
140                         if (envchanged)
141                                 *envchanged = 1;
142                         (*argv)++;
143                         (*argc)--;
144                 } else if (!prefixcmp(cmd, CMD_WORK_TREE)) {
145                         setenv(PERF_WORK_TREE_ENVIRONMENT, cmd + strlen(CMD_WORK_TREE), 1);
146                         if (envchanged)
147                                 *envchanged = 1;
148                 } else if (!strcmp(cmd, "--debugfs-dir")) {
149                         if (*argc < 2) {
150                                 fprintf(stderr, "No directory given for --debugfs-dir.\n");
151                                 usage(perf_usage_string);
152                         }
153                         debugfs_set_path((*argv)[1]);
154                         if (envchanged)
155                                 *envchanged = 1;
156                         (*argv)++;
157                         (*argc)--;
158                 } else if (!prefixcmp(cmd, CMD_DEBUGFS_DIR)) {
159                         debugfs_set_path(cmd + strlen(CMD_DEBUGFS_DIR));
160                         fprintf(stderr, "dir: %s\n", debugfs_mountpoint);
161                         if (envchanged)
162                                 *envchanged = 1;
163                 } else {
164                         fprintf(stderr, "Unknown option: %s\n", cmd);
165                         usage(perf_usage_string);
166                 }
167
168                 (*argv)++;
169                 (*argc)--;
170                 handled++;
171         }
172         return handled;
173 }
174
175 static int handle_alias(int *argcp, const char ***argv)
176 {
177         int envchanged = 0, ret = 0, saved_errno = errno;
178         int count, option_count;
179         const char **new_argv;
180         const char *alias_command;
181         char *alias_string;
182
183         alias_command = (*argv)[0];
184         alias_string = alias_lookup(alias_command);
185         if (alias_string) {
186                 if (alias_string[0] == '!') {
187                         if (*argcp > 1) {
188                                 struct strbuf buf;
189
190                                 strbuf_init(&buf, PATH_MAX);
191                                 strbuf_addstr(&buf, alias_string);
192                                 sq_quote_argv(&buf, (*argv) + 1, PATH_MAX);
193                                 free(alias_string);
194                                 alias_string = buf.buf;
195                         }
196                         ret = system(alias_string + 1);
197                         if (ret >= 0 && WIFEXITED(ret) &&
198                             WEXITSTATUS(ret) != 127)
199                                 exit(WEXITSTATUS(ret));
200                         die("Failed to run '%s' when expanding alias '%s'",
201                             alias_string + 1, alias_command);
202                 }
203                 count = split_cmdline(alias_string, &new_argv);
204                 if (count < 0)
205                         die("Bad alias.%s string", alias_command);
206                 option_count = handle_options(&new_argv, &count, &envchanged);
207                 if (envchanged)
208                         die("alias '%s' changes environment variables\n"
209                                  "You can use '!perf' in the alias to do this.",
210                                  alias_command);
211                 memmove(new_argv - option_count, new_argv,
212                                 count * sizeof(char *));
213                 new_argv -= option_count;
214
215                 if (count < 1)
216                         die("empty alias for %s", alias_command);
217
218                 if (!strcmp(alias_command, new_argv[0]))
219                         die("recursive alias: %s", alias_command);
220
221                 new_argv = realloc(new_argv, sizeof(char *) *
222                                     (count + *argcp + 1));
223                 /* insert after command name */
224                 memcpy(new_argv + count, *argv + 1, sizeof(char *) * *argcp);
225                 new_argv[count + *argcp] = NULL;
226
227                 *argv = new_argv;
228                 *argcp += count - 1;
229
230                 ret = 1;
231         }
232
233         errno = saved_errno;
234
235         return ret;
236 }
237
238 const char perf_version_string[] = PERF_VERSION;
239
240 #define RUN_SETUP       (1<<0)
241 #define USE_PAGER       (1<<1)
242 /*
243  * require working tree to be present -- anything uses this needs
244  * RUN_SETUP for reading from the configuration file.
245  */
246 #define NEED_WORK_TREE  (1<<2)
247
248 struct cmd_struct {
249         const char *cmd;
250         int (*fn)(int, const char **, const char *);
251         int option;
252 };
253
254 static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
255 {
256         int status;
257         struct stat st;
258         const char *prefix;
259
260         prefix = NULL;
261         if (p->option & RUN_SETUP)
262                 prefix = NULL; /* setup_perf_directory(); */
263
264         if (use_browser == -1)
265                 use_browser = check_tui_config(p->cmd);
266
267         if (use_pager == -1 && p->option & RUN_SETUP)
268                 use_pager = check_pager_config(p->cmd);
269         if (use_pager == -1 && p->option & USE_PAGER)
270                 use_pager = 1;
271         commit_pager_choice();
272
273         status = p->fn(argc, argv, prefix);
274         exit_browser(status);
275
276         if (status)
277                 return status & 0xff;
278
279         /* Somebody closed stdout? */
280         if (fstat(fileno(stdout), &st))
281                 return 0;
282         /* Ignore write errors for pipes and sockets.. */
283         if (S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode))
284                 return 0;
285
286         /* Check for ENOSPC and EIO errors.. */
287         if (fflush(stdout))
288                 die("write failure on standard output: %s", strerror(errno));
289         if (ferror(stdout))
290                 die("unknown write failure on standard output");
291         if (fclose(stdout))
292                 die("close failed on standard output: %s", strerror(errno));
293         return 0;
294 }
295
296 static void handle_internal_command(int argc, const char **argv)
297 {
298         const char *cmd = argv[0];
299         static struct cmd_struct commands[] = {
300                 { "buildid-cache", cmd_buildid_cache, 0 },
301                 { "buildid-list", cmd_buildid_list, 0 },
302                 { "diff",       cmd_diff,       0 },
303                 { "evlist",     cmd_evlist,     0 },
304                 { "help",       cmd_help,       0 },
305                 { "list",       cmd_list,       0 },
306                 { "record",     cmd_record,     0 },
307                 { "report",     cmd_report,     0 },
308                 { "bench",      cmd_bench,      0 },
309                 { "stat",       cmd_stat,       0 },
310                 { "timechart",  cmd_timechart,  0 },
311                 { "top",        cmd_top,        0 },
312                 { "annotate",   cmd_annotate,   0 },
313                 { "version",    cmd_version,    0 },
314                 { "script",     cmd_script,     0 },
315                 { "sched",      cmd_sched,      0 },
316                 { "probe",      cmd_probe,      0 },
317                 { "kmem",       cmd_kmem,       0 },
318                 { "lock",       cmd_lock,       0 },
319                 { "kvm",        cmd_kvm,        0 },
320                 { "test",       cmd_test,       0 },
321                 { "inject",     cmd_inject,     0 },
322         };
323         unsigned int i;
324         static const char ext[] = STRIP_EXTENSION;
325
326         if (sizeof(ext) > 1) {
327                 i = strlen(argv[0]) - strlen(ext);
328                 if (i > 0 && !strcmp(argv[0] + i, ext)) {
329                         char *argv0 = strdup(argv[0]);
330                         argv[0] = cmd = argv0;
331                         argv0[i] = '\0';
332                 }
333         }
334
335         /* Turn "perf cmd --help" into "perf help cmd" */
336         if (argc > 1 && !strcmp(argv[1], "--help")) {
337                 argv[1] = argv[0];
338                 argv[0] = cmd = "help";
339         }
340
341         for (i = 0; i < ARRAY_SIZE(commands); i++) {
342                 struct cmd_struct *p = commands+i;
343                 if (strcmp(p->cmd, cmd))
344                         continue;
345                 exit(run_builtin(p, argc, argv));
346         }
347 }
348
349 static void execv_dashed_external(const char **argv)
350 {
351         struct strbuf cmd = STRBUF_INIT;
352         const char *tmp;
353         int status;
354
355         strbuf_addf(&cmd, "perf-%s", argv[0]);
356
357         /*
358          * argv[0] must be the perf command, but the argv array
359          * belongs to the caller, and may be reused in
360          * subsequent loop iterations. Save argv[0] and
361          * restore it on error.
362          */
363         tmp = argv[0];
364         argv[0] = cmd.buf;
365
366         /*
367          * if we fail because the command is not found, it is
368          * OK to return. Otherwise, we just pass along the status code.
369          */
370         status = run_command_v_opt(argv, 0);
371         if (status != -ERR_RUN_COMMAND_EXEC) {
372                 if (IS_RUN_COMMAND_ERR(status))
373                         die("unable to run '%s'", argv[0]);
374                 exit(-status);
375         }
376         errno = ENOENT; /* as if we called execvp */
377
378         argv[0] = tmp;
379
380         strbuf_release(&cmd);
381 }
382
383 static int run_argv(int *argcp, const char ***argv)
384 {
385         int done_alias = 0;
386
387         while (1) {
388                 /* See if it's an internal command */
389                 handle_internal_command(*argcp, *argv);
390
391                 /* .. then try the external ones */
392                 execv_dashed_external(*argv);
393
394                 /* It could be an alias -- this works around the insanity
395                  * of overriding "perf log" with "perf show" by having
396                  * alias.log = show
397                  */
398                 if (done_alias || !handle_alias(argcp, argv))
399                         break;
400                 done_alias = 1;
401         }
402
403         return done_alias;
404 }
405
406 static void pthread__block_sigwinch(void)
407 {
408         sigset_t set;
409
410         sigemptyset(&set);
411         sigaddset(&set, SIGWINCH);
412         pthread_sigmask(SIG_BLOCK, &set, NULL);
413 }
414
415 void pthread__unblock_sigwinch(void)
416 {
417         sigset_t set;
418
419         sigemptyset(&set);
420         sigaddset(&set, SIGWINCH);
421         pthread_sigmask(SIG_UNBLOCK, &set, NULL);
422 }
423
424 int main(int argc, const char **argv)
425 {
426         const char *cmd;
427
428         cmd = perf_extract_argv0_path(argv[0]);
429         if (!cmd)
430                 cmd = "perf-help";
431         /* get debugfs mount point from /proc/mounts */
432         debugfs_mount(NULL);
433         /*
434          * "perf-xxxx" is the same as "perf xxxx", but we obviously:
435          *
436          *  - cannot take flags in between the "perf" and the "xxxx".
437          *  - cannot execute it externally (since it would just do
438          *    the same thing over again)
439          *
440          * So we just directly call the internal command handler, and
441          * die if that one cannot handle it.
442          */
443         if (!prefixcmp(cmd, "perf-")) {
444                 cmd += 5;
445                 argv[0] = cmd;
446                 handle_internal_command(argc, argv);
447                 die("cannot handle %s internally", cmd);
448         }
449
450         /* Look for flags.. */
451         argv++;
452         argc--;
453         handle_options(&argv, &argc, NULL);
454         commit_pager_choice();
455         set_buildid_dir();
456
457         if (argc > 0) {
458                 if (!prefixcmp(argv[0], "--"))
459                         argv[0] += 2;
460         } else {
461                 /* The user didn't specify a command; give them help */
462                 printf("\n usage: %s\n\n", perf_usage_string);
463                 list_common_cmds_help();
464                 printf("\n %s\n\n", perf_more_info_string);
465                 exit(1);
466         }
467         cmd = argv[0];
468
469         /*
470          * We use PATH to find perf commands, but we prepend some higher
471          * precedence paths: the "--exec-path" option, the PERF_EXEC_PATH
472          * environment, and the $(perfexecdir) from the Makefile at build
473          * time.
474          */
475         setup_path();
476         /*
477          * Block SIGWINCH notifications so that the thread that wants it can
478          * unblock and get syscalls like select interrupted instead of waiting
479          * forever while the signal goes to some other non interested thread.
480          */
481         pthread__block_sigwinch();
482
483         while (1) {
484                 static int done_help;
485                 static int was_alias;
486
487                 was_alias = run_argv(&argc, &argv);
488                 if (errno != ENOENT)
489                         break;
490
491                 if (was_alias) {
492                         fprintf(stderr, "Expansion of alias '%s' failed; "
493                                 "'%s' is not a perf-command\n",
494                                 cmd, argv[0]);
495                         exit(1);
496                 }
497                 if (!done_help) {
498                         cmd = argv[0] = help_unknown_cmd(cmd);
499                         done_help = 1;
500                 } else
501                         break;
502         }
503
504         fprintf(stderr, "Failed to run command '%s': %s\n",
505                 cmd, strerror(errno));
506
507         return 1;
508 }