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