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