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                 { "help",       cmd_help,       0 },
 290                 { "list",       cmd_list,       0 },
 291                 { "record",     cmd_record,     0 },
 292                 { "report",     cmd_report,     0 },
 293                 { "bench",      cmd_bench,      0 },
 294                 { "stat",       cmd_stat,       0 },
 295                 { "timechart",  cmd_timechart,  0 },
 296                 { "top",        cmd_top,        0 },
 297                 { "annotate",   cmd_annotate,   0 },
 298                 { "version",    cmd_version,    0 },
 299                 { "trace",      cmd_trace,      0 },
 300                 { "sched",      cmd_sched,      0 },
 301                 { "probe",      cmd_probe,      0 },
 302                 { "kmem",       cmd_kmem,       0 },
 303         };
 304         unsigned int i;
 305         static const char ext[] = STRIP_EXTENSION;
 306
 307         if (sizeof(ext) > 1) {
 308                 i = strlen(argv[0]) - strlen(ext);
 309                 if (i > 0 && !strcmp(argv[0] + i, ext)) {
 310                         char *argv0 = strdup(argv[0]);
 311                         argv[0] = cmd = argv0;
 312                         argv0[i] = '\0';
 313                 }
 314         }
 315
 316         /* Turn "perf cmd --help" into "perf help cmd" */
 317         if (argc > 1 && !strcmp(argv[1], "--help")) {
 318                 argv[1] = argv[0];
 319                 argv[0] = cmd = "help";
 320         }
 321
 322         for (i = 0; i < ARRAY_SIZE(commands); i++) {
 323                 struct cmd_struct *p = commands+i;
 324                 if (strcmp(p->cmd, cmd))
 325                         continue;
 326                 exit(run_builtin(p, argc, argv));
 327         }
 328 }
 329
 330 static void execv_dashed_external(const char **argv)
 331 {
 332         struct strbuf cmd = STRBUF_INIT;
 333         const char *tmp;
 334         int status;
 335
 336         strbuf_addf(&cmd, "perf-%s", argv[0]);
 337
 338         /*
 339          * argv[0] must be the perf command, but the argv array
 340          * belongs to the caller, and may be reused in
 341          * subsequent loop iterations. Save argv[0] and
 342          * restore it on error.
 343          */
 344         tmp = argv[0];
 345         argv[0] = cmd.buf;
 346
 347         /*
 348          * if we fail because the command is not found, it is
 349          * OK to return. Otherwise, we just pass along the status code.
 350          */
 351         status = run_command_v_opt(argv, 0);
 352         if (status != -ERR_RUN_COMMAND_EXEC) {
 353                 if (IS_RUN_COMMAND_ERR(status))
 354                         die("unable to run '%s'", argv[0]);
 355                 exit(-status);
 356         }
 357         errno = ENOENT; /* as if we called execvp */
 358
 359         argv[0] = tmp;
 360
 361         strbuf_release(&cmd);
 362 }
 363
 364 static int run_argv(int *argcp, const char ***argv)
 365 {
 366         int done_alias = 0;
 367
 368         while (1) {
 369                 /* See if it's an internal command */
 370                 handle_internal_command(*argcp, *argv);
 371
 372                 /* .. then try the external ones */
 373                 execv_dashed_external(*argv);
 374
 375                 /* It could be an alias -- this works around the insanity
 376                  * of overriding "perf log" with "perf show" by having
 377                  * alias.log = show
 378                  */
 379                 if (done_alias || !handle_alias(argcp, argv))
 380                         break;
 381                 done_alias = 1;
 382         }
 383
 384         return done_alias;
 385 }
 386
 387 /* mini /proc/mounts parser: searching for "^blah /mount/point debugfs" */
 388 static void get_debugfs_mntpt(void)
 389 {
 390         const char *path = debugfs_find_mountpoint();
 391
 392         if (path)
 393                 strncpy(debugfs_mntpt, path, sizeof(debugfs_mntpt));
 394         else
 395                 debugfs_mntpt[0] = '\0';
 396 }
 397
 398 int main(int argc, const char **argv)
 399 {
 400         const char *cmd;
 401
 402         cmd = perf_extract_argv0_path(argv[0]);
 403         if (!cmd)
 404                 cmd = "perf-help";
 405         /* get debugfs mount point from /proc/mounts */
 406         get_debugfs_mntpt();
 407         /*
 408          * "perf-xxxx" is the same as "perf xxxx", but we obviously:
 409          *
 410          *  - cannot take flags in between the "perf" and the "xxxx".
 411          *  - cannot execute it externally (since it would just do
 412          *    the same thing over again)
 413          *
 414          * So we just directly call the internal command handler, and
 415          * die if that one cannot handle it.
 416          */
 417         if (!prefixcmp(cmd, "perf-")) {
 418                 cmd += 5;
 419                 argv[0] = cmd;
 420                 handle_internal_command(argc, argv);
 421                 die("cannot handle %s internally", cmd);
 422         }
 423
 424         /* Look for flags.. */
 425         argv++;
 426         argc--;
 427         handle_options(&argv, &argc, NULL);
 428         commit_pager_choice();
 429         set_debugfs_path();
 430         if (argc > 0) {
 431                 if (!prefixcmp(argv[0], "--"))
 432                         argv[0] += 2;
 433         } else {
 434                 /* The user didn't specify a command; give them help */
 435                 printf("\n usage: %s\n\n", perf_usage_string);
 436                 list_common_cmds_help();
 437                 printf("\n %s\n\n", perf_more_info_string);
 438                 exit(1);
 439         }
 440         cmd = argv[0];
 441
 442         /*
 443          * We use PATH to find perf commands, but we prepend some higher
 444          * precidence paths: the "--exec-path" option, the PERF_EXEC_PATH
 445          * environment, and the $(perfexecdir) from the Makefile at build
 446          * time.
 447          */
 448         setup_path();
 449
 450         while (1) {
 451                 static int done_help = 0;
 452                 static int was_alias = 0;
 453
 454                 was_alias = run_argv(&argc, &argv);
 455                 if (errno != ENOENT)
 456                         break;
 457
 458                 if (was_alias) {
 459                         fprintf(stderr, "Expansion of alias '%s' failed; "
 460                                 "'%s' is not a perf-command\n",
 461                                 cmd, argv[0]);
 462                         exit(1);
 463                 }
 464                 if (!done_help) {
 465                         cmd = argv[0] = help_unknown_cmd(cmd);
 466                         done_help = 1;
 467                 } else
 468                         break;
 469         }
 470
 471         fprintf(stderr, "Failed to run command '%s': %s\n",
 472                 cmd, strerror(errno));
 473
 474         return 1;
 475 }