tools/perf/builtin-trace.c

   1 /*
   2  * builtin-trace.c
   3  *
   4  * Builtin 'trace' command:
   5  *
   6  * Display a continuously updated trace of any workload, CPU, specific PID,
   7  * system wide, etc.  Default format is loosely strace like, but any other
   8  * event may be specified using --event.
   9  *
  10  * Copyright (C) 2012, 2013, 2014, 2015 Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
  11  *
  12  * Initially based on the 'trace' prototype by Thomas Gleixner:
  13  *
  14  * http://lwn.net/Articles/415728/ ("Announcing a new utility: 'trace'")
  15  *
  16  * Released under the GPL v2. (and only v2, not any later version)
  17  */
  18
  19 #include <traceevent/event-parse.h>
  20 #include <api/fs/tracing_path.h>
  21 #include "builtin.h"
  22 #include "util/cgroup.h"
  23 #include "util/color.h"
  24 #include "util/debug.h"
  25 #include "util/env.h"
  26 #include "util/event.h"
  27 #include "util/evlist.h"
  28 #include <subcmd/exec-cmd.h>
  29 #include "util/machine.h"
  30 #include "util/path.h"
  31 #include "util/session.h"
  32 #include "util/thread.h"
  33 #include <subcmd/parse-options.h>
  34 #include "util/strlist.h"
  35 #include "util/intlist.h"
  36 #include "util/thread_map.h"
  37 #include "util/stat.h"
  38 #include "trace/beauty/beauty.h"
  39 #include "trace-event.h"
  40 #include "util/parse-events.h"
  41 #include "util/bpf-loader.h"
  42 #include "callchain.h"
  43 #include "print_binary.h"
  44 #include "string2.h"
  45 #include "syscalltbl.h"
  46 #include "rb_resort.h"
  47
  48 #include <errno.h>
  49 #include <inttypes.h>
  50 #include <poll.h>
  51 #include <signal.h>
  52 #include <stdlib.h>
  53 #include <string.h>
  54 #include <linux/err.h>
  55 #include <linux/filter.h>
  56 #include <linux/kernel.h>
  57 #include <linux/random.h>
  58 #include <linux/stringify.h>
  59 #include <linux/time64.h>
  60 #include <fcntl.h>
  61
  62 #include "sane_ctype.h"
  63
  64 #ifndef O_CLOEXEC
  65 # define O_CLOEXEC              02000000
  66 #endif
  67
  68 #ifndef F_LINUX_SPECIFIC_BASE
  69 # define F_LINUX_SPECIFIC_BASE  1024
  70 #endif
  71
  72 struct trace {
  73         struct perf_tool        tool;
  74         struct syscalltbl       *sctbl;
  75         struct {
  76                 int             max;
  77                 struct syscall  *table;
  78                 struct {
  79                         struct perf_evsel *sys_enter,
  80                                           *sys_exit;
  81                 }               events;
  82         } syscalls;
  83         struct record_opts      opts;
  84         struct perf_evlist      *evlist;
  85         struct machine          *host;
  86         struct thread           *current;
  87         struct cgroup           *cgroup;
  88         u64                     base_time;
  89         FILE                    *output;
  90         unsigned long           nr_events;
  91         struct strlist          *ev_qualifier;
  92         struct {
  93                 size_t          nr;
  94                 int             *entries;
  95         }                       ev_qualifier_ids;
  96         struct {
  97                 size_t          nr;
  98                 pid_t           *entries;
  99         }                       filter_pids;
 100         double                  duration_filter;
 101         double                  runtime_ms;
 102         struct {
 103                 u64             vfs_getname,
 104                                 proc_getname;
 105         } stats;
 106         unsigned int            max_stack;
 107         unsigned int            min_stack;
 108         bool                    not_ev_qualifier;
 109         bool                    live;
 110         bool                    full_time;
 111         bool                    sched;
 112         bool                    multiple_threads;
 113         bool                    summary;
 114         bool                    summary_only;
 115         bool                    failure_only;
 116         bool                    show_comm;
 117         bool                    print_sample;
 118         bool                    show_tool_stats;
 119         bool                    trace_syscalls;
 120         bool                    kernel_syscallchains;
 121         bool                    force;
 122         bool                    vfs_getname;
 123         int                     trace_pgfaults;
 124         int                     open_id;
 125 };
 126
 127 struct tp_field {
 128         int offset;
 129         union {
 130                 u64 (*integer)(struct tp_field *field, struct perf_sample *sample);
 131                 void *(*pointer)(struct tp_field *field, struct perf_sample *sample);
 132         };
 133 };
 134
 135 #define TP_UINT_FIELD(bits) \
 136 static u64 tp_field__u##bits(struct tp_field *field, struct perf_sample *sample) \
 137 { \
 138         u##bits value; \
 139         memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
 140         return value;  \
 141 }
 142
 143 TP_UINT_FIELD(8);
 144 TP_UINT_FIELD(16);
 145 TP_UINT_FIELD(32);
 146 TP_UINT_FIELD(64);
 147
 148 #define TP_UINT_FIELD__SWAPPED(bits) \
 149 static u64 tp_field__swapped_u##bits(struct tp_field *field, struct perf_sample *sample) \
 150 { \
 151         u##bits value; \
 152         memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
 153         return bswap_##bits(value);\
 154 }
 155
 156 TP_UINT_FIELD__SWAPPED(16);
 157 TP_UINT_FIELD__SWAPPED(32);
 158 TP_UINT_FIELD__SWAPPED(64);
 159
 160 static int tp_field__init_uint(struct tp_field *field,
 161                                struct format_field *format_field,
 162                                bool needs_swap)
 163 {
 164         field->offset = format_field->offset;
 165
 166         switch (format_field->size) {
 167         case 1:
 168                 field->integer = tp_field__u8;
 169                 break;
 170         case 2:
 171                 field->integer = needs_swap ? tp_field__swapped_u16 : tp_field__u16;
 172                 break;
 173         case 4:
 174                 field->integer = needs_swap ? tp_field__swapped_u32 : tp_field__u32;
 175                 break;
 176         case 8:
 177                 field->integer = needs_swap ? tp_field__swapped_u64 : tp_field__u64;
 178                 break;
 179         default:
 180                 return -1;
 181         }
 182
 183         return 0;
 184 }
 185
 186 static void *tp_field__ptr(struct tp_field *field, struct perf_sample *sample)
 187 {
 188         return sample->raw_data + field->offset;
 189 }
 190
 191 static int tp_field__init_ptr(struct tp_field *field, struct format_field *format_field)
 192 {
 193         field->offset = format_field->offset;
 194         field->pointer = tp_field__ptr;
 195         return 0;
 196 }
 197
 198 struct syscall_tp {
 199         struct tp_field id;
 200         union {
 201                 struct tp_field args, ret;
 202         };
 203 };
 204
 205 static int perf_evsel__init_tp_uint_field(struct perf_evsel *evsel,
 206                                           struct tp_field *field,
 207                                           const char *name)
 208 {
 209         struct format_field *format_field = perf_evsel__field(evsel, name);
 210
 211         if (format_field == NULL)
 212                 return -1;
 213
 214         return tp_field__init_uint(field, format_field, evsel->needs_swap);
 215 }
 216
 217 #define perf_evsel__init_sc_tp_uint_field(evsel, name) \
 218         ({ struct syscall_tp *sc = evsel->priv;\
 219            perf_evsel__init_tp_uint_field(evsel, &sc->name, #name); })
 220
 221 static int perf_evsel__init_tp_ptr_field(struct perf_evsel *evsel,
 222                                          struct tp_field *field,
 223                                          const char *name)
 224 {
 225         struct format_field *format_field = perf_evsel__field(evsel, name);
 226
 227         if (format_field == NULL)
 228                 return -1;
 229
 230         return tp_field__init_ptr(field, format_field);
 231 }
 232
 233 #define perf_evsel__init_sc_tp_ptr_field(evsel, name) \
 234         ({ struct syscall_tp *sc = evsel->priv;\
 235            perf_evsel__init_tp_ptr_field(evsel, &sc->name, #name); })
 236
 237 static void perf_evsel__delete_priv(struct perf_evsel *evsel)
 238 {
 239         zfree(&evsel->priv);
 240         perf_evsel__delete(evsel);
 241 }
 242
 243 static int perf_evsel__init_syscall_tp(struct perf_evsel *evsel, void *handler)
 244 {
 245         evsel->priv = malloc(sizeof(struct syscall_tp));
 246         if (evsel->priv != NULL) {
 247                 if (perf_evsel__init_sc_tp_uint_field(evsel, id))
 248                         goto out_delete;
 249
 250                 evsel->handler = handler;
 251                 return 0;
 252         }
 253
 254         return -ENOMEM;
 255
 256 out_delete:
 257         zfree(&evsel->priv);
 258         return -ENOENT;
 259 }
 260
 261 static struct perf_evsel *perf_evsel__syscall_newtp(const char *direction, void *handler)
 262 {
 263         struct perf_evsel *evsel = perf_evsel__newtp("raw_syscalls", direction);
 264
 265         /* older kernel (e.g., RHEL6) use syscalls:{enter,exit} */
 266         if (IS_ERR(evsel))
 267                 evsel = perf_evsel__newtp("syscalls", direction);
 268
 269         if (IS_ERR(evsel))
 270                 return NULL;
 271
 272         if (perf_evsel__init_syscall_tp(evsel, handler))
 273                 goto out_delete;
 274
 275         return evsel;
 276
 277 out_delete:
 278         perf_evsel__delete_priv(evsel);
 279         return NULL;
 280 }
 281
 282 #define perf_evsel__sc_tp_uint(evsel, name, sample) \
 283         ({ struct syscall_tp *fields = evsel->priv; \
 284            fields->name.integer(&fields->name, sample); })
 285
 286 #define perf_evsel__sc_tp_ptr(evsel, name, sample) \
 287         ({ struct syscall_tp *fields = evsel->priv; \
 288            fields->name.pointer(&fields->name, sample); })
 289
 290 size_t strarray__scnprintf(struct strarray *sa, char *bf, size_t size, const char *intfmt, int val)
 291 {
 292         int idx = val - sa->offset;
 293
 294         if (idx < 0 || idx >= sa->nr_entries)
 295                 return scnprintf(bf, size, intfmt, val);
 296
 297         return scnprintf(bf, size, "%s", sa->entries[idx]);
 298 }
 299
 300 static size_t __syscall_arg__scnprintf_strarray(char *bf, size_t size,
 301                                                 const char *intfmt,
 302                                                 struct syscall_arg *arg)
 303 {
 304         return strarray__scnprintf(arg->parm, bf, size, intfmt, arg->val);
 305 }
 306
 307 static size_t syscall_arg__scnprintf_strarray(char *bf, size_t size,
 308                                               struct syscall_arg *arg)
 309 {
 310         return __syscall_arg__scnprintf_strarray(bf, size, "%d", arg);
 311 }
 312
 313 #define SCA_STRARRAY syscall_arg__scnprintf_strarray
 314
 315 struct strarrays {
 316         int             nr_entries;
 317         struct strarray **entries;
 318 };
 319
 320 #define DEFINE_STRARRAYS(array) struct strarrays strarrays__##array = { \
 321         .nr_entries = ARRAY_SIZE(array), \
 322         .entries = array, \
 323 }
 324
 325 size_t syscall_arg__scnprintf_strarrays(char *bf, size_t size,
 326                                         struct syscall_arg *arg)
 327 {
 328         struct strarrays *sas = arg->parm;
 329         int i;
 330
 331         for (i = 0; i < sas->nr_entries; ++i) {
 332                 struct strarray *sa = sas->entries[i];
 333                 int idx = arg->val - sa->offset;
 334
 335                 if (idx >= 0 && idx < sa->nr_entries) {
 336                         if (sa->entries[idx] == NULL)
 337                                 break;
 338                         return scnprintf(bf, size, "%s", sa->entries[idx]);
 339                 }
 340         }
 341
 342         return scnprintf(bf, size, "%d", arg->val);
 343 }
 344
 345 #ifndef AT_FDCWD
 346 #define AT_FDCWD        -100
 347 #endif
 348
 349 static size_t syscall_arg__scnprintf_fd_at(char *bf, size_t size,
 350                                            struct syscall_arg *arg)
 351 {
 352         int fd = arg->val;
 353
 354         if (fd == AT_FDCWD)
 355                 return scnprintf(bf, size, "CWD");
 356
 357         return syscall_arg__scnprintf_fd(bf, size, arg);
 358 }
 359
 360 #define SCA_FDAT syscall_arg__scnprintf_fd_at
 361
 362 static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
 363                                               struct syscall_arg *arg);
 364
 365 #define SCA_CLOSE_FD syscall_arg__scnprintf_close_fd
 366
 367 size_t syscall_arg__scnprintf_hex(char *bf, size_t size, struct syscall_arg *arg)
 368 {
 369         return scnprintf(bf, size, "%#lx", arg->val);
 370 }
 371
 372 size_t syscall_arg__scnprintf_int(char *bf, size_t size, struct syscall_arg *arg)
 373 {
 374         return scnprintf(bf, size, "%d", arg->val);
 375 }
 376
 377 size_t syscall_arg__scnprintf_long(char *bf, size_t size, struct syscall_arg *arg)
 378 {
 379         return scnprintf(bf, size, "%ld", arg->val);
 380 }
 381
 382 static const char *bpf_cmd[] = {
 383         "MAP_CREATE", "MAP_LOOKUP_ELEM", "MAP_UPDATE_ELEM", "MAP_DELETE_ELEM",
 384         "MAP_GET_NEXT_KEY", "PROG_LOAD",
 385 };
 386 static DEFINE_STRARRAY(bpf_cmd);
 387
 388 static const char *epoll_ctl_ops[] = { "ADD", "DEL", "MOD", };
 389 static DEFINE_STRARRAY_OFFSET(epoll_ctl_ops, 1);
 390
 391 static const char *itimers[] = { "REAL", "VIRTUAL", "PROF", };
 392 static DEFINE_STRARRAY(itimers);
 393
 394 static const char *keyctl_options[] = {
 395         "GET_KEYRING_ID", "JOIN_SESSION_KEYRING", "UPDATE", "REVOKE", "CHOWN",
 396         "SETPERM", "DESCRIBE", "CLEAR", "LINK", "UNLINK", "SEARCH", "READ",
 397         "INSTANTIATE", "NEGATE", "SET_REQKEY_KEYRING", "SET_TIMEOUT",
 398         "ASSUME_AUTHORITY", "GET_SECURITY", "SESSION_TO_PARENT", "REJECT",
 399         "INSTANTIATE_IOV", "INVALIDATE", "GET_PERSISTENT",
 400 };
 401 static DEFINE_STRARRAY(keyctl_options);
 402
 403 static const char *whences[] = { "SET", "CUR", "END",
 404 #ifdef SEEK_DATA
 405 "DATA",
 406 #endif
 407 #ifdef SEEK_HOLE
 408 "HOLE",
 409 #endif
 410 };
 411 static DEFINE_STRARRAY(whences);
 412
 413 static const char *fcntl_cmds[] = {
 414         "DUPFD", "GETFD", "SETFD", "GETFL", "SETFL", "GETLK", "SETLK",
 415         "SETLKW", "SETOWN", "GETOWN", "SETSIG", "GETSIG", "GETLK64",
 416         "SETLK64", "SETLKW64", "SETOWN_EX", "GETOWN_EX",
 417         "GETOWNER_UIDS",
 418 };
 419 static DEFINE_STRARRAY(fcntl_cmds);
 420
 421 static const char *fcntl_linux_specific_cmds[] = {
 422         "SETLEASE", "GETLEASE", "NOTIFY", [5] = "CANCELLK", "DUPFD_CLOEXEC",
 423         "SETPIPE_SZ", "GETPIPE_SZ", "ADD_SEALS", "GET_SEALS",
 424         "GET_RW_HINT", "SET_RW_HINT", "GET_FILE_RW_HINT", "SET_FILE_RW_HINT",
 425 };
 426
 427 static DEFINE_STRARRAY_OFFSET(fcntl_linux_specific_cmds, F_LINUX_SPECIFIC_BASE);
 428
 429 static struct strarray *fcntl_cmds_arrays[] = {
 430         &strarray__fcntl_cmds,
 431         &strarray__fcntl_linux_specific_cmds,
 432 };
 433
 434 static DEFINE_STRARRAYS(fcntl_cmds_arrays);
 435
 436 static const char *rlimit_resources[] = {
 437         "CPU", "FSIZE", "DATA", "STACK", "CORE", "RSS", "NPROC", "NOFILE",
 438         "MEMLOCK", "AS", "LOCKS", "SIGPENDING", "MSGQUEUE", "NICE", "RTPRIO",
 439         "RTTIME",
 440 };
 441 static DEFINE_STRARRAY(rlimit_resources);
 442
 443 static const char *sighow[] = { "BLOCK", "UNBLOCK", "SETMASK", };
 444 static DEFINE_STRARRAY(sighow);
 445
 446 static const char *clockid[] = {
 447         "REALTIME", "MONOTONIC", "PROCESS_CPUTIME_ID", "THREAD_CPUTIME_ID",
 448         "MONOTONIC_RAW", "REALTIME_COARSE", "MONOTONIC_COARSE", "BOOTTIME",
 449         "REALTIME_ALARM", "BOOTTIME_ALARM", "SGI_CYCLE", "TAI"
 450 };
 451 static DEFINE_STRARRAY(clockid);
 452
 453 static const char *socket_families[] = {
 454         "UNSPEC", "LOCAL", "INET", "AX25", "IPX", "APPLETALK", "NETROM",
 455         "BRIDGE", "ATMPVC", "X25", "INET6", "ROSE", "DECnet", "NETBEUI",
 456         "SECURITY", "KEY", "NETLINK", "PACKET", "ASH", "ECONET", "ATMSVC",
 457         "RDS", "SNA", "IRDA", "PPPOX", "WANPIPE", "LLC", "IB", "CAN", "TIPC",
 458         "BLUETOOTH", "IUCV", "RXRPC", "ISDN", "PHONET", "IEEE802154", "CAIF",
 459         "ALG", "NFC", "VSOCK",
 460 };
 461 static DEFINE_STRARRAY(socket_families);
 462
 463 static size_t syscall_arg__scnprintf_access_mode(char *bf, size_t size,
 464                                                  struct syscall_arg *arg)
 465 {
 466         size_t printed = 0;
 467         int mode = arg->val;
 468
 469         if (mode == F_OK) /* 0 */
 470                 return scnprintf(bf, size, "F");
 471 #define P_MODE(n) \
 472         if (mode & n##_OK) { \
 473                 printed += scnprintf(bf + printed, size - printed, "%s", #n); \
 474                 mode &= ~n##_OK; \
 475         }
 476
 477         P_MODE(R);
 478         P_MODE(W);
 479         P_MODE(X);
 480 #undef P_MODE
 481
 482         if (mode)
 483                 printed += scnprintf(bf + printed, size - printed, "|%#x", mode);
 484
 485         return printed;
 486 }
 487
 488 #define SCA_ACCMODE syscall_arg__scnprintf_access_mode
 489
 490 static size_t syscall_arg__scnprintf_filename(char *bf, size_t size,
 491                                               struct syscall_arg *arg);
 492
 493 #define SCA_FILENAME syscall_arg__scnprintf_filename
 494
 495 static size_t syscall_arg__scnprintf_pipe_flags(char *bf, size_t size,
 496                                                 struct syscall_arg *arg)
 497 {
 498         int printed = 0, flags = arg->val;
 499
 500 #define P_FLAG(n) \
 501         if (flags & O_##n) { \
 502                 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
 503                 flags &= ~O_##n; \
 504         }
 505
 506         P_FLAG(CLOEXEC);
 507         P_FLAG(NONBLOCK);
 508 #undef P_FLAG
 509
 510         if (flags)
 511                 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
 512
 513         return printed;
 514 }
 515
 516 #define SCA_PIPE_FLAGS syscall_arg__scnprintf_pipe_flags
 517
 518 #ifndef GRND_NONBLOCK
 519 #define GRND_NONBLOCK   0x0001
 520 #endif
 521 #ifndef GRND_RANDOM
 522 #define GRND_RANDOM     0x0002
 523 #endif
 524
 525 static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size,
 526                                                    struct syscall_arg *arg)
 527 {
 528         int printed = 0, flags = arg->val;
 529
 530 #define P_FLAG(n) \
 531         if (flags & GRND_##n) { \
 532                 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
 533                 flags &= ~GRND_##n; \
 534         }
 535
 536         P_FLAG(RANDOM);
 537         P_FLAG(NONBLOCK);
 538 #undef P_FLAG
 539
 540         if (flags)
 541                 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
 542
 543         return printed;
 544 }
 545
 546 #define SCA_GETRANDOM_FLAGS syscall_arg__scnprintf_getrandom_flags
 547
 548 #define STRARRAY(name, array) \
 549           { .scnprintf  = SCA_STRARRAY, \
 550             .parm       = &strarray__##array, }
 551
 552 #include "trace/beauty/arch_errno_names.c"
 553 #include "trace/beauty/eventfd.c"
 554 #include "trace/beauty/futex_op.c"
 555 #include "trace/beauty/futex_val3.c"
 556 #include "trace/beauty/mmap.c"
 557 #include "trace/beauty/mode_t.c"
 558 #include "trace/beauty/msg_flags.c"
 559 #include "trace/beauty/open_flags.c"
 560 #include "trace/beauty/perf_event_open.c"
 561 #include "trace/beauty/pid.c"
 562 #include "trace/beauty/sched_policy.c"
 563 #include "trace/beauty/seccomp.c"
 564 #include "trace/beauty/signum.c"
 565 #include "trace/beauty/socket_type.c"
 566 #include "trace/beauty/waitid_options.c"
 567
 568 struct syscall_arg_fmt {
 569         size_t     (*scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
 570         void       *parm;
 571         const char *name;
 572         bool       show_zero;
 573 };
 574
 575 static struct syscall_fmt {
 576         const char *name;
 577         const char *alias;
 578         struct syscall_arg_fmt arg[6];
 579         u8         nr_args;
 580         bool       errpid;
 581         bool       timeout;
 582         bool       hexret;
 583 } syscall_fmts[] = {
 584         { .name     = "access",
 585           .arg = { [1] = { .scnprintf = SCA_ACCMODE,  /* mode */ }, }, },
 586         { .name     = "bpf",
 587           .arg = { [0] = STRARRAY(cmd, bpf_cmd), }, },
 588         { .name     = "brk",        .hexret = true,
 589           .arg = { [0] = { .scnprintf = SCA_HEX, /* brk */ }, }, },
 590         { .name     = "clock_gettime",
 591           .arg = { [0] = STRARRAY(clk_id, clockid), }, },
 592         { .name     = "clone",      .errpid = true, .nr_args = 5,
 593           .arg = { [0] = { .name = "flags",         .scnprintf = SCA_CLONE_FLAGS, },
 594                    [1] = { .name = "child_stack",   .scnprintf = SCA_HEX, },
 595                    [2] = { .name = "parent_tidptr", .scnprintf = SCA_HEX, },
 596                    [3] = { .name = "child_tidptr",  .scnprintf = SCA_HEX, },
 597                    [4] = { .name = "tls",           .scnprintf = SCA_HEX, }, }, },
 598         { .name     = "close",
 599           .arg = { [0] = { .scnprintf = SCA_CLOSE_FD, /* fd */ }, }, },
 600         { .name     = "epoll_ctl",
 601           .arg = { [1] = STRARRAY(op, epoll_ctl_ops), }, },
 602         { .name     = "eventfd2",
 603           .arg = { [1] = { .scnprintf = SCA_EFD_FLAGS, /* flags */ }, }, },
 604         { .name     = "fchmodat",
 605           .arg = { [0] = { .scnprintf = SCA_FDAT, /* fd */ }, }, },
 606         { .name     = "fchownat",
 607           .arg = { [0] = { .scnprintf = SCA_FDAT, /* fd */ }, }, },
 608         { .name     = "fcntl",
 609           .arg = { [1] = { .scnprintf = SCA_FCNTL_CMD, /* cmd */
 610                            .parm      = &strarrays__fcntl_cmds_arrays,
 611                            .show_zero = true, },
 612                    [2] = { .scnprintf =  SCA_FCNTL_ARG, /* arg */ }, }, },
 613         { .name     = "flock",
 614           .arg = { [1] = { .scnprintf = SCA_FLOCK, /* cmd */ }, }, },
 615         { .name     = "fstat", .alias = "newfstat", },
 616         { .name     = "fstatat", .alias = "newfstatat", },
 617         { .name     = "futex",
 618           .arg = { [1] = { .scnprintf = SCA_FUTEX_OP, /* op */ },
 619                    [5] = { .scnprintf = SCA_FUTEX_VAL3, /* val3 */ }, }, },
 620         { .name     = "futimesat",
 621           .arg = { [0] = { .scnprintf = SCA_FDAT, /* fd */ }, }, },
 622         { .name     = "getitimer",
 623           .arg = { [0] = STRARRAY(which, itimers), }, },
 624         { .name     = "getpid",     .errpid = true, },
 625         { .name     = "getpgid",    .errpid = true, },
 626         { .name     = "getppid",    .errpid = true, },
 627         { .name     = "getrandom",
 628           .arg = { [2] = { .scnprintf = SCA_GETRANDOM_FLAGS, /* flags */ }, }, },
 629         { .name     = "getrlimit",
 630           .arg = { [0] = STRARRAY(resource, rlimit_resources), }, },
 631         { .name     = "gettid",     .errpid = true, },
 632         { .name     = "ioctl",
 633           .arg = {
 634 #if defined(__i386__) || defined(__x86_64__)
 635 /*
 636  * FIXME: Make this available to all arches.
 637  */
 638                    [1] = { .scnprintf = SCA_IOCTL_CMD, /* cmd */ },
 639                    [2] = { .scnprintf = SCA_HEX, /* arg */ }, }, },
 640 #else
 641                    [2] = { .scnprintf = SCA_HEX, /* arg */ }, }, },
 642 #endif
 643         { .name     = "kcmp",       .nr_args = 5,
 644           .arg = { [0] = { .name = "pid1",      .scnprintf = SCA_PID, },
 645                    [1] = { .name = "pid2",      .scnprintf = SCA_PID, },
 646                    [2] = { .name = "type",      .scnprintf = SCA_KCMP_TYPE, },
 647                    [3] = { .name = "idx1",      .scnprintf = SCA_KCMP_IDX, },
 648                    [4] = { .name = "idx2",      .scnprintf = SCA_KCMP_IDX, }, }, },
 649         { .name     = "keyctl",
 650           .arg = { [0] = STRARRAY(option, keyctl_options), }, },
 651         { .name     = "kill",
 652           .arg = { [1] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
 653         { .name     = "linkat",
 654           .arg = { [0] = { .scnprintf = SCA_FDAT, /* fd */ }, }, },
 655         { .name     = "lseek",
 656           .arg = { [2] = STRARRAY(whence, whences), }, },
 657         { .name     = "lstat", .alias = "newlstat", },
 658         { .name     = "madvise",
 659           .arg = { [0] = { .scnprintf = SCA_HEX,      /* start */ },
 660                    [2] = { .scnprintf = SCA_MADV_BHV, /* behavior */ }, }, },
 661         { .name     = "mkdirat",
 662           .arg = { [0] = { .scnprintf = SCA_FDAT, /* fd */ }, }, },
 663         { .name     = "mknodat",
 664           .arg = { [0] = { .scnprintf = SCA_FDAT, /* fd */ }, }, },
 665         { .name     = "mlock",
 666           .arg = { [0] = { .scnprintf = SCA_HEX, /* addr */ }, }, },
 667         { .name     = "mlockall",
 668           .arg = { [0] = { .scnprintf = SCA_HEX, /* addr */ }, }, },
 669         { .name     = "mmap",       .hexret = true,
 670 /* The standard mmap maps to old_mmap on s390x */
 671 #if defined(__s390x__)
 672         .alias = "old_mmap",
 673 #endif
 674           .arg = { [0] = { .scnprintf = SCA_HEX,        /* addr */ },
 675                    [2] = { .scnprintf = SCA_MMAP_PROT,  /* prot */ },
 676                    [3] = { .scnprintf = SCA_MMAP_FLAGS, /* flags */ }, }, },
 677         { .name     = "mprotect",
 678           .arg = { [0] = { .scnprintf = SCA_HEX,        /* start */ },
 679                    [2] = { .scnprintf = SCA_MMAP_PROT,  /* prot */ }, }, },
 680         { .name     = "mq_unlink",
 681           .arg = { [0] = { .scnprintf = SCA_FILENAME, /* u_name */ }, }, },
 682         { .name     = "mremap",     .hexret = true,
 683           .arg = { [0] = { .scnprintf = SCA_HEX,          /* addr */ },
 684                    [3] = { .scnprintf = SCA_MREMAP_FLAGS, /* flags */ },
 685                    [4] = { .scnprintf = SCA_HEX,          /* new_addr */ }, }, },
 686         { .name     = "munlock",
 687           .arg = { [0] = { .scnprintf = SCA_HEX, /* addr */ }, }, },
 688         { .name     = "munmap",
 689           .arg = { [0] = { .scnprintf = SCA_HEX, /* addr */ }, }, },
 690         { .name     = "name_to_handle_at",
 691           .arg = { [0] = { .scnprintf = SCA_FDAT, /* dfd */ }, }, },
 692         { .name     = "newfstatat",
 693           .arg = { [0] = { .scnprintf = SCA_FDAT, /* dfd */ }, }, },
 694         { .name     = "open",
 695           .arg = { [1] = { .scnprintf = SCA_OPEN_FLAGS, /* flags */ }, }, },
 696         { .name     = "open_by_handle_at",
 697           .arg = { [0] = { .scnprintf = SCA_FDAT,       /* dfd */ },
 698                    [2] = { .scnprintf = SCA_OPEN_FLAGS, /* flags */ }, }, },
 699         { .name     = "openat",
 700           .arg = { [0] = { .scnprintf = SCA_FDAT,       /* dfd */ },
 701                    [2] = { .scnprintf = SCA_OPEN_FLAGS, /* flags */ }, }, },
 702         { .name     = "perf_event_open",
 703           .arg = { [2] = { .scnprintf = SCA_INT,        /* cpu */ },
 704                    [3] = { .scnprintf = SCA_FD,         /* group_fd */ },
 705                    [4] = { .scnprintf = SCA_PERF_FLAGS, /* flags */ }, }, },
 706         { .name     = "pipe2",
 707           .arg = { [1] = { .scnprintf = SCA_PIPE_FLAGS, /* flags */ }, }, },
 708         { .name     = "pkey_alloc",
 709           .arg = { [1] = { .scnprintf = SCA_PKEY_ALLOC_ACCESS_RIGHTS,   /* access_rights */ }, }, },
 710         { .name     = "pkey_free",
 711           .arg = { [0] = { .scnprintf = SCA_INT,        /* key */ }, }, },
 712         { .name     = "pkey_mprotect",
 713           .arg = { [0] = { .scnprintf = SCA_HEX,        /* start */ },
 714                    [2] = { .scnprintf = SCA_MMAP_PROT,  /* prot */ },
 715                    [3] = { .scnprintf = SCA_INT,        /* pkey */ }, }, },
 716         { .name     = "poll", .timeout = true, },
 717         { .name     = "ppoll", .timeout = true, },
 718         { .name     = "prctl", .alias = "arch_prctl",
 719           .arg = { [0] = { .scnprintf = SCA_PRCTL_OPTION, /* option */ },
 720                    [1] = { .scnprintf = SCA_PRCTL_ARG2, /* arg2 */ },
 721                    [2] = { .scnprintf = SCA_PRCTL_ARG3, /* arg3 */ }, }, },
 722         { .name     = "pread", .alias = "pread64", },
 723         { .name     = "preadv", .alias = "pread", },
 724         { .name     = "prlimit64",
 725           .arg = { [1] = STRARRAY(resource, rlimit_resources), }, },
 726         { .name     = "pwrite", .alias = "pwrite64", },
 727         { .name     = "readlinkat",
 728           .arg = { [0] = { .scnprintf = SCA_FDAT, /* dfd */ }, }, },
 729         { .name     = "recvfrom",
 730           .arg = { [3] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
 731         { .name     = "recvmmsg",
 732           .arg = { [3] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
 733         { .name     = "recvmsg",
 734           .arg = { [2] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
 735         { .name     = "renameat",
 736           .arg = { [0] = { .scnprintf = SCA_FDAT, /* dfd */ }, }, },
 737         { .name     = "rt_sigaction",
 738           .arg = { [0] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
 739         { .name     = "rt_sigprocmask",
 740           .arg = { [0] = STRARRAY(how, sighow), }, },
 741         { .name     = "rt_sigqueueinfo",
 742           .arg = { [1] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
 743         { .name     = "rt_tgsigqueueinfo",
 744           .arg = { [2] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
 745         { .name     = "sched_setscheduler",
 746           .arg = { [1] = { .scnprintf = SCA_SCHED_POLICY, /* policy */ }, }, },
 747         { .name     = "seccomp",
 748           .arg = { [0] = { .scnprintf = SCA_SECCOMP_OP,    /* op */ },
 749                    [1] = { .scnprintf = SCA_SECCOMP_FLAGS, /* flags */ }, }, },
 750         { .name     = "select", .timeout = true, },
 751         { .name     = "sendmmsg",
 752           .arg = { [3] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
 753         { .name     = "sendmsg",
 754           .arg = { [2] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
 755         { .name     = "sendto",
 756           .arg = { [3] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
 757         { .name     = "set_tid_address", .errpid = true, },
 758         { .name     = "setitimer",
 759           .arg = { [0] = STRARRAY(which, itimers), }, },
 760         { .name     = "setrlimit",
 761           .arg = { [0] = STRARRAY(resource, rlimit_resources), }, },
 762         { .name     = "socket",
 763           .arg = { [0] = STRARRAY(family, socket_families),
 764                    [1] = { .scnprintf = SCA_SK_TYPE, /* type */ }, }, },
 765         { .name     = "socketpair",
 766           .arg = { [0] = STRARRAY(family, socket_families),
 767                    [1] = { .scnprintf = SCA_SK_TYPE, /* type */ }, }, },
 768         { .name     = "stat", .alias = "newstat", },
 769         { .name     = "statx",
 770           .arg = { [0] = { .scnprintf = SCA_FDAT,        /* fdat */ },
 771                    [2] = { .scnprintf = SCA_STATX_FLAGS, /* flags */ } ,
 772                    [3] = { .scnprintf = SCA_STATX_MASK,  /* mask */ }, }, },
 773         { .name     = "swapoff",
 774           .arg = { [0] = { .scnprintf = SCA_FILENAME, /* specialfile */ }, }, },
 775         { .name     = "swapon",
 776           .arg = { [0] = { .scnprintf = SCA_FILENAME, /* specialfile */ }, }, },
 777         { .name     = "symlinkat",
 778           .arg = { [0] = { .scnprintf = SCA_FDAT, /* dfd */ }, }, },
 779         { .name     = "tgkill",
 780           .arg = { [2] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
 781         { .name     = "tkill",
 782           .arg = { [1] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
 783         { .name     = "uname", .alias = "newuname", },
 784         { .name     = "unlinkat",
 785           .arg = { [0] = { .scnprintf = SCA_FDAT, /* dfd */ }, }, },
 786         { .name     = "utimensat",
 787           .arg = { [0] = { .scnprintf = SCA_FDAT, /* dirfd */ }, }, },
 788         { .name     = "wait4",      .errpid = true,
 789           .arg = { [2] = { .scnprintf = SCA_WAITID_OPTIONS, /* options */ }, }, },
 790         { .name     = "waitid",     .errpid = true,
 791           .arg = { [3] = { .scnprintf = SCA_WAITID_OPTIONS, /* options */ }, }, },
 792 };
 793
 794 static int syscall_fmt__cmp(const void *name, const void *fmtp)
 795 {
 796         const struct syscall_fmt *fmt = fmtp;
 797         return strcmp(name, fmt->name);
 798 }
 799
 800 static struct syscall_fmt *syscall_fmt__find(const char *name)
 801 {
 802         const int nmemb = ARRAY_SIZE(syscall_fmts);
 803         return bsearch(name, syscall_fmts, nmemb, sizeof(struct syscall_fmt), syscall_fmt__cmp);
 804 }
 805
 806 struct syscall {
 807         struct event_format *tp_format;
 808         int                 nr_args;
 809         struct format_field *args;
 810         const char          *name;
 811         bool                is_exit;
 812         struct syscall_fmt  *fmt;
 813         struct syscall_arg_fmt *arg_fmt;
 814 };
 815
 816 /*
 817  * We need to have this 'calculated' boolean because in some cases we really
 818  * don't know what is the duration of a syscall, for instance, when we start
 819  * a session and some threads are waiting for a syscall to finish, say 'poll',
 820  * in which case all we can do is to print "( ? ) for duration and for the
 821  * start timestamp.
 822  */
 823 static size_t fprintf_duration(unsigned long t, bool calculated, FILE *fp)
 824 {
 825         double duration = (double)t / NSEC_PER_MSEC;
 826         size_t printed = fprintf(fp, "(");
 827
 828         if (!calculated)
 829                 printed += fprintf(fp, "         ");
 830         else if (duration >= 1.0)
 831                 printed += color_fprintf(fp, PERF_COLOR_RED, "%6.3f ms", duration);
 832         else if (duration >= 0.01)
 833                 printed += color_fprintf(fp, PERF_COLOR_YELLOW, "%6.3f ms", duration);
 834         else
 835                 printed += color_fprintf(fp, PERF_COLOR_NORMAL, "%6.3f ms", duration);
 836         return printed + fprintf(fp, "): ");
 837 }
 838
 839 /**
 840  * filename.ptr: The filename char pointer that will be vfs_getname'd
 841  * filename.entry_str_pos: Where to insert the string translated from
 842  *                         filename.ptr by the vfs_getname tracepoint/kprobe.
 843  * ret_scnprintf: syscall args may set this to a different syscall return
 844  *                formatter, for instance, fcntl may return fds, file flags, etc.
 845  */
 846 struct thread_trace {
 847         u64               entry_time;
 848         bool              entry_pending;
 849         unsigned long     nr_events;
 850         unsigned long     pfmaj, pfmin;
 851         char              *entry_str;
 852         double            runtime_ms;
 853         size_t            (*ret_scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
 854         struct {
 855                 unsigned long ptr;
 856                 short int     entry_str_pos;
 857                 bool          pending_open;
 858                 unsigned int  namelen;
 859                 char          *name;
 860         } filename;
 861         struct {
 862                 int       max;
 863                 char      **table;
 864         } paths;
 865
 866         struct intlist *syscall_stats;
 867 };
 868
 869 static struct thread_trace *thread_trace__new(void)
 870 {
 871         struct thread_trace *ttrace =  zalloc(sizeof(struct thread_trace));
 872
 873         if (ttrace)
 874                 ttrace->paths.max = -1;
 875
 876         ttrace->syscall_stats = intlist__new(NULL);
 877
 878         return ttrace;
 879 }
 880
 881 static struct thread_trace *thread__trace(struct thread *thread, FILE *fp)
 882 {
 883         struct thread_trace *ttrace;
 884
 885         if (thread == NULL)
 886                 goto fail;
 887
 888         if (thread__priv(thread) == NULL)
 889                 thread__set_priv(thread, thread_trace__new());
 890
 891         if (thread__priv(thread) == NULL)
 892                 goto fail;
 893
 894         ttrace = thread__priv(thread);
 895         ++ttrace->nr_events;
 896
 897         return ttrace;
 898 fail:
 899         color_fprintf(fp, PERF_COLOR_RED,
 900                       "WARNING: not enough memory, dropping samples!\n");
 901         return NULL;
 902 }
 903
 904
 905 void syscall_arg__set_ret_scnprintf(struct syscall_arg *arg,
 906                                     size_t (*ret_scnprintf)(char *bf, size_t size, struct syscall_arg *arg))
 907 {
 908         struct thread_trace *ttrace = thread__priv(arg->thread);
 909
 910         ttrace->ret_scnprintf = ret_scnprintf;
 911 }
 912
 913 #define TRACE_PFMAJ             (1 << 0)
 914 #define TRACE_PFMIN             (1 << 1)
 915
 916 static const size_t trace__entry_str_size = 2048;
 917
 918 static int trace__set_fd_pathname(struct thread *thread, int fd, const char *pathname)
 919 {
 920         struct thread_trace *ttrace = thread__priv(thread);
 921
 922         if (fd > ttrace->paths.max) {
 923                 char **npath = realloc(ttrace->paths.table, (fd + 1) * sizeof(char *));
 924
 925                 if (npath == NULL)
 926                         return -1;
 927
 928                 if (ttrace->paths.max != -1) {
 929                         memset(npath + ttrace->paths.max + 1, 0,
 930                                (fd - ttrace->paths.max) * sizeof(char *));
 931                 } else {
 932                         memset(npath, 0, (fd + 1) * sizeof(char *));
 933                 }
 934
 935                 ttrace->paths.table = npath;
 936                 ttrace->paths.max   = fd;
 937         }
 938
 939         ttrace->paths.table[fd] = strdup(pathname);
 940
 941         return ttrace->paths.table[fd] != NULL ? 0 : -1;
 942 }
 943
 944 static int thread__read_fd_path(struct thread *thread, int fd)
 945 {
 946         char linkname[PATH_MAX], pathname[PATH_MAX];
 947         struct stat st;
 948         int ret;
 949
 950         if (thread->pid_ == thread->tid) {
 951                 scnprintf(linkname, sizeof(linkname),
 952                           "/proc/%d/fd/%d", thread->pid_, fd);
 953         } else {
 954                 scnprintf(linkname, sizeof(linkname),
 955                           "/proc/%d/task/%d/fd/%d", thread->pid_, thread->tid, fd);
 956         }
 957
 958         if (lstat(linkname, &st) < 0 || st.st_size + 1 > (off_t)sizeof(pathname))
 959                 return -1;
 960
 961         ret = readlink(linkname, pathname, sizeof(pathname));
 962
 963         if (ret < 0 || ret > st.st_size)
 964                 return -1;
 965
 966         pathname[ret] = '\0';
 967         return trace__set_fd_pathname(thread, fd, pathname);
 968 }
 969
 970 static const char *thread__fd_path(struct thread *thread, int fd,
 971                                    struct trace *trace)
 972 {
 973         struct thread_trace *ttrace = thread__priv(thread);
 974
 975         if (ttrace == NULL)
 976                 return NULL;
 977
 978         if (fd < 0)
 979                 return NULL;
 980
 981         if ((fd > ttrace->paths.max || ttrace->paths.table[fd] == NULL)) {
 982                 if (!trace->live)
 983                         return NULL;
 984                 ++trace->stats.proc_getname;
 985                 if (thread__read_fd_path(thread, fd))
 986                         return NULL;
 987         }
 988
 989         return ttrace->paths.table[fd];
 990 }
 991
 992 size_t syscall_arg__scnprintf_fd(char *bf, size_t size, struct syscall_arg *arg)
 993 {
 994         int fd = arg->val;
 995         size_t printed = scnprintf(bf, size, "%d", fd);
 996         const char *path = thread__fd_path(arg->thread, fd, arg->trace);
 997
 998         if (path)
 999                 printed += scnprintf(bf + printed, size - printed, "<%s>", path);
1000
1001         return printed;
1002 }
1003
1004 size_t pid__scnprintf_fd(struct trace *trace, pid_t pid, int fd, char *bf, size_t size)
1005 {
1006         size_t printed = scnprintf(bf, size, "%d", fd);
1007         struct thread *thread = machine__find_thread(trace->host, pid, pid);
1008
1009         if (thread) {
1010                 const char *path = thread__fd_path(thread, fd, trace);
1011
1012                 if (path)
1013                         printed += scnprintf(bf + printed, size - printed, "<%s>", path);
1014
1015                 thread__put(thread);
1016         }
1017
1018         return printed;
1019 }
1020
1021 static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
1022                                               struct syscall_arg *arg)
1023 {
1024         int fd = arg->val;
1025         size_t printed = syscall_arg__scnprintf_fd(bf, size, arg);
1026         struct thread_trace *ttrace = thread__priv(arg->thread);
1027
1028         if (ttrace && fd >= 0 && fd <= ttrace->paths.max)
1029                 zfree(&ttrace->paths.table[fd]);
1030
1031         return printed;
1032 }
1033
1034 static void thread__set_filename_pos(struct thread *thread, const char *bf,
1035                                      unsigned long ptr)
1036 {
1037         struct thread_trace *ttrace = thread__priv(thread);
1038
1039         ttrace->filename.ptr = ptr;
1040         ttrace->filename.entry_str_pos = bf - ttrace->entry_str;
1041 }
1042
1043 static size_t syscall_arg__scnprintf_filename(char *bf, size_t size,
1044                                               struct syscall_arg *arg)
1045 {
1046         unsigned long ptr = arg->val;
1047
1048         if (!arg->trace->vfs_getname)
1049                 return scnprintf(bf, size, "%#x", ptr);
1050
1051         thread__set_filename_pos(arg->thread, bf, ptr);
1052         return 0;
1053 }
1054
1055 static bool trace__filter_duration(struct trace *trace, double t)
1056 {
1057         return t < (trace->duration_filter * NSEC_PER_MSEC);
1058 }
1059
1060 static size_t __trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
1061 {
1062         double ts = (double)(tstamp - trace->base_time) / NSEC_PER_MSEC;
1063
1064         return fprintf(fp, "%10.3f ", ts);
1065 }
1066
1067 /*
1068  * We're handling tstamp=0 as an undefined tstamp, i.e. like when we are
1069  * using ttrace->entry_time for a thread that receives a sys_exit without
1070  * first having received a sys_enter ("poll" issued before tracing session
1071  * starts, lost sys_enter exit due to ring buffer overflow).
1072  */
1073 static size_t trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
1074 {
1075         if (tstamp > 0)
1076                 return __trace__fprintf_tstamp(trace, tstamp, fp);
1077
1078         return fprintf(fp, "         ? ");
1079 }
1080
1081 static bool done = false;
1082 static bool interrupted = false;
1083
1084 static void sig_handler(int sig)
1085 {
1086         done = true;
1087         interrupted = sig == SIGINT;
1088 }
1089
1090 static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
1091                                         u64 duration, bool duration_calculated, u64 tstamp, FILE *fp)
1092 {
1093         size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
1094         printed += fprintf_duration(duration, duration_calculated, fp);
1095
1096         if (trace->multiple_threads) {
1097                 if (trace->show_comm)
1098                         printed += fprintf(fp, "%.14s/", thread__comm_str(thread));
1099                 printed += fprintf(fp, "%d ", thread->tid);
1100         }
1101
1102         return printed;
1103 }
1104
1105 static int trace__process_event(struct trace *trace, struct machine *machine,
1106                                 union perf_event *event, struct perf_sample *sample)
1107 {
1108         int ret = 0;
1109
1110         switch (event->header.type) {
1111         case PERF_RECORD_LOST:
1112                 color_fprintf(trace->output, PERF_COLOR_RED,
1113                               "LOST %" PRIu64 " events!\n", event->lost.lost);
1114                 ret = machine__process_lost_event(machine, event, sample);
1115                 break;
1116         default:
1117                 ret = machine__process_event(machine, event, sample);
1118                 break;
1119         }
1120
1121         return ret;
1122 }
1123
1124 static int trace__tool_process(struct perf_tool *tool,
1125                                union perf_event *event,
1126                                struct perf_sample *sample,
1127                                struct machine *machine)
1128 {
1129         struct trace *trace = container_of(tool, struct trace, tool);
1130         return trace__process_event(trace, machine, event, sample);
1131 }
1132
1133 static char *trace__machine__resolve_kernel_addr(void *vmachine, unsigned long long *addrp, char **modp)
1134 {
1135         struct machine *machine = vmachine;
1136
1137         if (machine->kptr_restrict_warned)
1138                 return NULL;
1139
1140         if (symbol_conf.kptr_restrict) {
1141                 pr_warning("Kernel address maps (/proc/{kallsyms,modules}) are restricted.\n\n"
1142                            "Check /proc/sys/kernel/kptr_restrict.\n\n"
1143                            "Kernel samples will not be resolved.\n");
1144                 machine->kptr_restrict_warned = true;
1145                 return NULL;
1146         }
1147
1148         return machine__resolve_kernel_addr(vmachine, addrp, modp);
1149 }
1150
1151 static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
1152 {
1153         int err = symbol__init(NULL);
1154
1155         if (err)
1156                 return err;
1157
1158         trace->host = machine__new_host();
1159         if (trace->host == NULL)
1160                 return -ENOMEM;
1161
1162         err = trace_event__register_resolver(trace->host, trace__machine__resolve_kernel_addr);
1163         if (err < 0)
1164                 goto out;
1165
1166         err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target,
1167                                             evlist->threads, trace__tool_process, false,
1168                                             trace->opts.proc_map_timeout, 1);
1169 out:
1170         if (err)
1171                 symbol__exit();
1172
1173         return err;
1174 }
1175
1176 static void trace__symbols__exit(struct trace *trace)
1177 {
1178         machine__exit(trace->host);
1179         trace->host = NULL;
1180
1181         symbol__exit();
1182 }
1183
1184 static int syscall__alloc_arg_fmts(struct syscall *sc, int nr_args)
1185 {
1186         int idx;
1187
1188         if (nr_args == 6 && sc->fmt && sc->fmt->nr_args != 0)
1189                 nr_args = sc->fmt->nr_args;
1190
1191         sc->arg_fmt = calloc(nr_args, sizeof(*sc->arg_fmt));
1192         if (sc->arg_fmt == NULL)
1193                 return -1;
1194
1195         for (idx = 0; idx < nr_args; ++idx) {
1196                 if (sc->fmt)
1197                         sc->arg_fmt[idx] = sc->fmt->arg[idx];
1198         }
1199
1200         sc->nr_args = nr_args;
1201         return 0;
1202 }
1203
1204 static int syscall__set_arg_fmts(struct syscall *sc)
1205 {
1206         struct format_field *field;
1207         int idx = 0, len;
1208
1209         for (field = sc->args; field; field = field->next, ++idx) {
1210                 if (sc->fmt && sc->fmt->arg[idx].scnprintf)
1211                         continue;
1212
1213                 if (strcmp(field->type, "const char *") == 0 &&
1214                          (strcmp(field->name, "filename") == 0 ||
1215                           strcmp(field->name, "path") == 0 ||
1216                           strcmp(field->name, "pathname") == 0))
1217                         sc->arg_fmt[idx].scnprintf = SCA_FILENAME;
1218                 else if (field->flags & FIELD_IS_POINTER)
1219                         sc->arg_fmt[idx].scnprintf = syscall_arg__scnprintf_hex;
1220                 else if (strcmp(field->type, "pid_t") == 0)
1221                         sc->arg_fmt[idx].scnprintf = SCA_PID;
1222                 else if (strcmp(field->type, "umode_t") == 0)
1223                         sc->arg_fmt[idx].scnprintf = SCA_MODE_T;
1224                 else if ((strcmp(field->type, "int") == 0 ||
1225                           strcmp(field->type, "unsigned int") == 0 ||
1226                           strcmp(field->type, "long") == 0) &&
1227                          (len = strlen(field->name)) >= 2 &&
1228                          strcmp(field->name + len - 2, "fd") == 0) {
1229                         /*
1230                          * /sys/kernel/tracing/events/syscalls/sys_enter*
1231                          * egrep 'field:.*fd;' .../format|sed -r 's/.*field:([a-z ]+) [a-z_]*fd.+/\1/g'|sort|uniq -c
1232                          * 65 int
1233                          * 23 unsigned int
1234                          * 7 unsigned long
1235                          */
1236                         sc->arg_fmt[idx].scnprintf = SCA_FD;
1237                 }
1238         }
1239
1240         return 0;
1241 }
1242
1243 static int trace__read_syscall_info(struct trace *trace, int id)
1244 {
1245         char tp_name[128];
1246         struct syscall *sc;
1247         const char *name = syscalltbl__name(trace->sctbl, id);
1248
1249         if (name == NULL)
1250                 return -1;
1251
1252         if (id > trace->syscalls.max) {
1253                 struct syscall *nsyscalls = realloc(trace->syscalls.table, (id + 1) * sizeof(*sc));
1254
1255                 if (nsyscalls == NULL)
1256                         return -1;
1257
1258                 if (trace->syscalls.max != -1) {
1259                         memset(nsyscalls + trace->syscalls.max + 1, 0,
1260                                (id - trace->syscalls.max) * sizeof(*sc));
1261                 } else {
1262                         memset(nsyscalls, 0, (id + 1) * sizeof(*sc));
1263                 }
1264
1265                 trace->syscalls.table = nsyscalls;
1266                 trace->syscalls.max   = id;
1267         }
1268
1269         sc = trace->syscalls.table + id;
1270         sc->name = name;
1271
1272         sc->fmt  = syscall_fmt__find(sc->name);
1273
1274         snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->name);
1275         sc->tp_format = trace_event__tp_format("syscalls", tp_name);
1276
1277         if (IS_ERR(sc->tp_format) && sc->fmt && sc->fmt->alias) {
1278                 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->fmt->alias);
1279                 sc->tp_format = trace_event__tp_format("syscalls", tp_name);
1280         }
1281
1282         if (syscall__alloc_arg_fmts(sc, IS_ERR(sc->tp_format) ? 6 : sc->tp_format->format.nr_fields))
1283                 return -1;
1284
1285         if (IS_ERR(sc->tp_format))
1286                 return -1;
1287
1288         sc->args = sc->tp_format->format.fields;
1289         /*
1290          * We need to check and discard the first variable '__syscall_nr'
1291          * or 'nr' that mean the syscall number. It is needless here.
1292          * So drop '__syscall_nr' or 'nr' field but does not exist on older kernels.
1293          */
1294         if (sc->args && (!strcmp(sc->args->name, "__syscall_nr") || !strcmp(sc->args->name, "nr"))) {
1295                 sc->args = sc->args->next;
1296                 --sc->nr_args;
1297         }
1298
1299         sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
1300
1301         return syscall__set_arg_fmts(sc);
1302 }
1303
1304 static int trace__validate_ev_qualifier(struct trace *trace)
1305 {
1306         int err = 0, i;
1307         size_t nr_allocated;
1308         struct str_node *pos;
1309
1310         trace->ev_qualifier_ids.nr = strlist__nr_entries(trace->ev_qualifier);
1311         trace->ev_qualifier_ids.entries = malloc(trace->ev_qualifier_ids.nr *
1312                                                  sizeof(trace->ev_qualifier_ids.entries[0]));
1313
1314         if (trace->ev_qualifier_ids.entries == NULL) {
1315                 fputs("Error:\tNot enough memory for allocating events qualifier ids\n",
1316                        trace->output);
1317                 err = -EINVAL;
1318                 goto out;
1319         }
1320
1321         nr_allocated = trace->ev_qualifier_ids.nr;
1322         i = 0;
1323
1324         strlist__for_each_entry(pos, trace->ev_qualifier) {
1325                 const char *sc = pos->s;
1326                 int id = syscalltbl__id(trace->sctbl, sc), match_next = -1;
1327
1328                 if (id < 0) {
1329                         id = syscalltbl__strglobmatch_first(trace->sctbl, sc, &match_next);
1330                         if (id >= 0)
1331                                 goto matches;
1332
1333                         if (err == 0) {
1334                                 fputs("Error:\tInvalid syscall ", trace->output);
1335                                 err = -EINVAL;
1336                         } else {
1337                                 fputs(", ", trace->output);
1338                         }
1339
1340                         fputs(sc, trace->output);
1341                 }
1342 matches:
1343                 trace->ev_qualifier_ids.entries[i++] = id;
1344                 if (match_next == -1)
1345                         continue;
1346
1347                 while (1) {
1348                         id = syscalltbl__strglobmatch_next(trace->sctbl, sc, &match_next);
1349                         if (id < 0)
1350                                 break;
1351                         if (nr_allocated == trace->ev_qualifier_ids.nr) {
1352                                 void *entries;
1353
1354                                 nr_allocated += 8;
1355                                 entries = realloc(trace->ev_qualifier_ids.entries,
1356                                                   nr_allocated * sizeof(trace->ev_qualifier_ids.entries[0]));
1357                                 if (entries == NULL) {
1358                                         err = -ENOMEM;
1359                                         fputs("\nError:\t Not enough memory for parsing\n", trace->output);
1360                                         goto out_free;
1361                                 }
1362                                 trace->ev_qualifier_ids.entries = entries;
1363                         }
1364                         trace->ev_qualifier_ids.nr++;
1365                         trace->ev_qualifier_ids.entries[i++] = id;
1366                 }
1367         }
1368
1369         if (err < 0) {
1370                 fputs("\nHint:\ttry 'perf list syscalls:sys_enter_*'"
1371                       "\nHint:\tand: 'man syscalls'\n", trace->output);
1372 out_free:
1373                 zfree(&trace->ev_qualifier_ids.entries);
1374                 trace->ev_qualifier_ids.nr = 0;
1375         }
1376 out:
1377         return err;
1378 }
1379
1380 /*
1381  * args is to be interpreted as a series of longs but we need to handle
1382  * 8-byte unaligned accesses. args points to raw_data within the event
1383  * and raw_data is guaranteed to be 8-byte unaligned because it is
1384  * preceded by raw_size which is a u32. So we need to copy args to a temp
1385  * variable to read it. Most notably this avoids extended load instructions
1386  * on unaligned addresses
1387  */
1388 unsigned long syscall_arg__val(struct syscall_arg *arg, u8 idx)
1389 {
1390         unsigned long val;
1391         unsigned char *p = arg->args + sizeof(unsigned long) * idx;
1392
1393         memcpy(&val, p, sizeof(val));
1394         return val;
1395 }
1396
1397 static size_t syscall__scnprintf_name(struct syscall *sc, char *bf, size_t size,
1398                                       struct syscall_arg *arg)
1399 {
1400         if (sc->arg_fmt && sc->arg_fmt[arg->idx].name)
1401                 return scnprintf(bf, size, "%s: ", sc->arg_fmt[arg->idx].name);
1402
1403         return scnprintf(bf, size, "arg%d: ", arg->idx);
1404 }
1405
1406 static size_t syscall__scnprintf_val(struct syscall *sc, char *bf, size_t size,
1407                                      struct syscall_arg *arg, unsigned long val)
1408 {
1409         if (sc->arg_fmt && sc->arg_fmt[arg->idx].scnprintf) {
1410                 arg->val = val;
1411                 if (sc->arg_fmt[arg->idx].parm)
1412                         arg->parm = sc->arg_fmt[arg->idx].parm;
1413                 return sc->arg_fmt[arg->idx].scnprintf(bf, size, arg);
1414         }
1415         return scnprintf(bf, size, "%ld", val);
1416 }
1417
1418 static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
1419                                       unsigned char *args, struct trace *trace,
1420                                       struct thread *thread)
1421 {
1422         size_t printed = 0;
1423         unsigned long val;
1424         u8 bit = 1;
1425         struct syscall_arg arg = {
1426                 .args   = args,
1427                 .idx    = 0,
1428                 .mask   = 0,
1429                 .trace  = trace,
1430                 .thread = thread,
1431         };
1432         struct thread_trace *ttrace = thread__priv(thread);
1433
1434         /*
1435          * Things like fcntl will set this in its 'cmd' formatter to pick the
1436          * right formatter for the return value (an fd? file flags?), which is
1437          * not needed for syscalls that always return a given type, say an fd.
1438          */
1439         ttrace->ret_scnprintf = NULL;
1440
1441         if (sc->args != NULL) {
1442                 struct format_field *field;
1443
1444                 for (field = sc->args; field;
1445                      field = field->next, ++arg.idx, bit <<= 1) {
1446                         if (arg.mask & bit)
1447                                 continue;
1448
1449                         val = syscall_arg__val(&arg, arg.idx);
1450
1451                         /*
1452                          * Suppress this argument if its value is zero and
1453                          * and we don't have a string associated in an
1454                          * strarray for it.
1455                          */
1456                         if (val == 0 &&
1457                             !(sc->arg_fmt &&
1458                               (sc->arg_fmt[arg.idx].show_zero ||
1459                                sc->arg_fmt[arg.idx].scnprintf == SCA_STRARRAY ||
1460                                sc->arg_fmt[arg.idx].scnprintf == SCA_STRARRAYS) &&
1461                               sc->arg_fmt[arg.idx].parm))
1462                                 continue;
1463
1464                         printed += scnprintf(bf + printed, size - printed,
1465                                              "%s%s: ", printed ? ", " : "", field->name);
1466                         printed += syscall__scnprintf_val(sc, bf + printed, size - printed, &arg, val);
1467                 }
1468         } else if (IS_ERR(sc->tp_format)) {
1469                 /*
1470                  * If we managed to read the tracepoint /format file, then we
1471                  * may end up not having any args, like with gettid(), so only
1472                  * print the raw args when we didn't manage to read it.
1473                  */
1474                 while (arg.idx < sc->nr_args) {
1475                         if (arg.mask & bit)
1476                                 goto next_arg;
1477                         val = syscall_arg__val(&arg, arg.idx);
1478                         if (printed)
1479                                 printed += scnprintf(bf + printed, size - printed, ", ");
1480                         printed += syscall__scnprintf_name(sc, bf + printed, size - printed, &arg);
1481                         printed += syscall__scnprintf_val(sc, bf + printed, size - printed, &arg, val);
1482 next_arg:
1483                         ++arg.idx;
1484                         bit <<= 1;
1485                 }
1486         }
1487
1488         return printed;
1489 }
1490
1491 typedef int (*tracepoint_handler)(struct trace *trace, struct perf_evsel *evsel,
1492                                   union perf_event *event,
1493                                   struct perf_sample *sample);
1494
1495 static struct syscall *trace__syscall_info(struct trace *trace,
1496                                            struct perf_evsel *evsel, int id)
1497 {
1498
1499         if (id < 0) {
1500
1501                 /*
1502                  * XXX: Noticed on x86_64, reproduced as far back as 3.0.36, haven't tried
1503                  * before that, leaving at a higher verbosity level till that is
1504                  * explained. Reproduced with plain ftrace with:
1505                  *
1506                  * echo 1 > /t/events/raw_syscalls/sys_exit/enable
1507                  * grep "NR -1 " /t/trace_pipe
1508                  *
1509                  * After generating some load on the machine.
1510                  */
1511                 if (verbose > 1) {
1512                         static u64 n;
1513                         fprintf(trace->output, "Invalid syscall %d id, skipping (%s, %" PRIu64 ") ...\n",
1514                                 id, perf_evsel__name(evsel), ++n);
1515                 }
1516                 return NULL;
1517         }
1518
1519         if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL) &&
1520             trace__read_syscall_info(trace, id))
1521                 goto out_cant_read;
1522
1523         if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL))
1524                 goto out_cant_read;
1525
1526         return &trace->syscalls.table[id];
1527
1528 out_cant_read:
1529         if (verbose > 0) {
1530                 fprintf(trace->output, "Problems reading syscall %d", id);
1531                 if (id <= trace->syscalls.max && trace->syscalls.table[id].name != NULL)
1532                         fprintf(trace->output, "(%s)", trace->syscalls.table[id].name);
1533                 fputs(" information\n", trace->output);
1534         }
1535         return NULL;
1536 }
1537
1538 static void thread__update_stats(struct thread_trace *ttrace,
1539                                  int id, struct perf_sample *sample)
1540 {
1541         struct int_node *inode;
1542         struct stats *stats;
1543         u64 duration = 0;
1544
1545         inode = intlist__findnew(ttrace->syscall_stats, id);
1546         if (inode == NULL)
1547                 return;
1548
1549         stats = inode->priv;
1550         if (stats == NULL) {
1551                 stats = malloc(sizeof(struct stats));
1552                 if (stats == NULL)
1553                         return;
1554                 init_stats(stats);
1555                 inode->priv = stats;
1556         }
1557
1558         if (ttrace->entry_time && sample->time > ttrace->entry_time)
1559                 duration = sample->time - ttrace->entry_time;
1560
1561         update_stats(stats, duration);
1562 }
1563
1564 static int trace__printf_interrupted_entry(struct trace *trace)
1565 {
1566         struct thread_trace *ttrace;
1567         size_t printed;
1568
1569         if (trace->failure_only || trace->current == NULL)
1570                 return 0;
1571
1572         ttrace = thread__priv(trace->current);
1573
1574         if (!ttrace->entry_pending)
1575                 return 0;
1576
1577         printed  = trace__fprintf_entry_head(trace, trace->current, 0, false, ttrace->entry_time, trace->output);
1578         printed += fprintf(trace->output, "%-70s) ...\n", ttrace->entry_str);
1579         ttrace->entry_pending = false;
1580
1581         return printed;
1582 }
1583
1584 static int trace__fprintf_sample(struct trace *trace, struct perf_evsel *evsel,
1585                                  struct perf_sample *sample, struct thread *thread)
1586 {
1587         int printed = 0;
1588
1589         if (trace->print_sample) {
1590                 double ts = (double)sample->time / NSEC_PER_MSEC;
1591
1592                 printed += fprintf(trace->output, "%22s %10.3f %s %d/%d [%d]\n",
1593                                    perf_evsel__name(evsel), ts,
1594                                    thread__comm_str(thread),
1595                                    sample->pid, sample->tid, sample->cpu);
1596         }
1597
1598         return printed;
1599 }
1600
1601 static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
1602                             union perf_event *event __maybe_unused,
1603                             struct perf_sample *sample)
1604 {
1605         char *msg;
1606         void *args;
1607         size_t printed = 0;
1608         struct thread *thread;
1609         int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1;
1610         struct syscall *sc = trace__syscall_info(trace, evsel, id);
1611         struct thread_trace *ttrace;
1612
1613         if (sc == NULL)
1614                 return -1;
1615
1616         thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1617         ttrace = thread__trace(thread, trace->output);
1618         if (ttrace == NULL)
1619                 goto out_put;
1620
1621         trace__fprintf_sample(trace, evsel, sample, thread);
1622
1623         args = perf_evsel__sc_tp_ptr(evsel, args, sample);
1624
1625         if (ttrace->entry_str == NULL) {
1626                 ttrace->entry_str = malloc(trace__entry_str_size);
1627                 if (!ttrace->entry_str)
1628                         goto out_put;
1629         }
1630
1631         if (!(trace->duration_filter || trace->summary_only || trace->min_stack))
1632                 trace__printf_interrupted_entry(trace);
1633
1634         ttrace->entry_time = sample->time;
1635         msg = ttrace->entry_str;
1636         printed += scnprintf(msg + printed, trace__entry_str_size - printed, "%s(", sc->name);
1637
1638         printed += syscall__scnprintf_args(sc, msg + printed, trace__entry_str_size - printed,
1639                                            args, trace, thread);
1640
1641         if (sc->is_exit) {
1642                 if (!(trace->duration_filter || trace->summary_only || trace->failure_only || trace->min_stack)) {
1643                         trace__fprintf_entry_head(trace, thread, 0, false, ttrace->entry_time, trace->output);
1644                         fprintf(trace->output, "%-70s)\n", ttrace->entry_str);
1645                 }
1646         } else {
1647                 ttrace->entry_pending = true;
1648                 /* See trace__vfs_getname & trace__sys_exit */
1649                 ttrace->filename.pending_open = false;
1650         }
1651
1652         if (trace->current != thread) {
1653                 thread__put(trace->current);
1654                 trace->current = thread__get(thread);
1655         }
1656         err = 0;
1657 out_put:
1658         thread__put(thread);
1659         return err;
1660 }
1661
1662 static int trace__resolve_callchain(struct trace *trace, struct perf_evsel *evsel,
1663                                     struct perf_sample *sample,
1664                                     struct callchain_cursor *cursor)
1665 {
1666         struct addr_location al;
1667         int max_stack = evsel->attr.sample_max_stack ?
1668                         evsel->attr.sample_max_stack :
1669                         trace->max_stack;
1670
1671         if (machine__resolve(trace->host, &al, sample) < 0 ||
1672             thread__resolve_callchain(al.thread, cursor, evsel, sample, NULL, NULL, max_stack))
1673                 return -1;
1674
1675         return 0;
1676 }
1677
1678 static int trace__fprintf_callchain(struct trace *trace, struct perf_sample *sample)
1679 {
1680         /* TODO: user-configurable print_opts */
1681         const unsigned int print_opts = EVSEL__PRINT_SYM |
1682                                         EVSEL__PRINT_DSO |
1683                                         EVSEL__PRINT_UNKNOWN_AS_ADDR;
1684
1685         return sample__fprintf_callchain(sample, 38, print_opts, &callchain_cursor, trace->output);
1686 }
1687
1688 static const char *errno_to_name(struct perf_evsel *evsel, int err)
1689 {
1690         struct perf_env *env = perf_evsel__env(evsel);
1691         const char *arch_name = perf_env__arch(env);
1692
1693         return arch_syscalls__strerrno(arch_name, err);
1694 }
1695
1696 static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
1697                            union perf_event *event __maybe_unused,
1698                            struct perf_sample *sample)
1699 {
1700         long ret;
1701         u64 duration = 0;
1702         bool duration_calculated = false;
1703         struct thread *thread;
1704         int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1, callchain_ret = 0;
1705         struct syscall *sc = trace__syscall_info(trace, evsel, id);
1706         struct thread_trace *ttrace;
1707
1708         if (sc == NULL)
1709                 return -1;
1710
1711         thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1712         ttrace = thread__trace(thread, trace->output);
1713         if (ttrace == NULL)
1714                 goto out_put;
1715
1716         trace__fprintf_sample(trace, evsel, sample, thread);
1717
1718         if (trace->summary)
1719                 thread__update_stats(ttrace, id, sample);
1720
1721         ret = perf_evsel__sc_tp_uint(evsel, ret, sample);
1722
1723         if (id == trace->open_id && ret >= 0 && ttrace->filename.pending_open) {
1724                 trace__set_fd_pathname(thread, ret, ttrace->filename.name);
1725                 ttrace->filename.pending_open = false;
1726                 ++trace->stats.vfs_getname;
1727         }
1728
1729         if (ttrace->entry_time) {
1730                 duration = sample->time - ttrace->entry_time;
1731                 if (trace__filter_duration(trace, duration))
1732                         goto out;
1733                 duration_calculated = true;
1734         } else if (trace->duration_filter)
1735                 goto out;
1736
1737         if (sample->callchain) {
1738                 callchain_ret = trace__resolve_callchain(trace, evsel, sample, &callchain_cursor);
1739                 if (callchain_ret == 0) {
1740                         if (callchain_cursor.nr < trace->min_stack)
1741                                 goto out;
1742                         callchain_ret = 1;
1743                 }
1744         }
1745
1746         if (trace->summary_only || (ret >= 0 && trace->failure_only))
1747                 goto out;
1748
1749         trace__fprintf_entry_head(trace, thread, duration, duration_calculated, ttrace->entry_time, trace->output);
1750
1751         if (ttrace->entry_pending) {
1752                 fprintf(trace->output, "%-70s", ttrace->entry_str);
1753         } else {
1754                 fprintf(trace->output, " ... [");
1755                 color_fprintf(trace->output, PERF_COLOR_YELLOW, "continued");
1756                 fprintf(trace->output, "]: %s()", sc->name);
1757         }
1758
1759         if (sc->fmt == NULL) {
1760                 if (ret < 0)
1761                         goto errno_print;
1762 signed_print:
1763                 fprintf(trace->output, ") = %ld", ret);
1764         } else if (ret < 0) {
1765 errno_print: {
1766                 char bf[STRERR_BUFSIZE];
1767                 const char *emsg = str_error_r(-ret, bf, sizeof(bf)),
1768                            *e = errno_to_name(evsel, -ret);
1769
1770                 fprintf(trace->output, ") = -1 %s %s", e, emsg);
1771         }
1772         } else if (ret == 0 && sc->fmt->timeout)
1773                 fprintf(trace->output, ") = 0 Timeout");
1774         else if (ttrace->ret_scnprintf) {
1775                 char bf[1024];
1776                 struct syscall_arg arg = {
1777                         .val    = ret,
1778                         .thread = thread,
1779                         .trace  = trace,
1780                 };
1781                 ttrace->ret_scnprintf(bf, sizeof(bf), &arg);
1782                 ttrace->ret_scnprintf = NULL;
1783                 fprintf(trace->output, ") = %s", bf);
1784         } else if (sc->fmt->hexret)
1785                 fprintf(trace->output, ") = %#lx", ret);
1786         else if (sc->fmt->errpid) {
1787                 struct thread *child = machine__find_thread(trace->host, ret, ret);
1788
1789                 if (child != NULL) {
1790                         fprintf(trace->output, ") = %ld", ret);
1791                         if (child->comm_set)
1792                                 fprintf(trace->output, " (%s)", thread__comm_str(child));
1793                         thread__put(child);
1794                 }
1795         } else
1796                 goto signed_print;
1797
1798         fputc('\n', trace->output);
1799
1800         if (callchain_ret > 0)
1801                 trace__fprintf_callchain(trace, sample);
1802         else if (callchain_ret < 0)
1803                 pr_err("Problem processing %s callchain, skipping...\n", perf_evsel__name(evsel));
1804 out:
1805         ttrace->entry_pending = false;
1806         err = 0;
1807 out_put:
1808         thread__put(thread);
1809         return err;
1810 }
1811
1812 static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
1813                               union perf_event *event __maybe_unused,
1814                               struct perf_sample *sample)
1815 {
1816         struct thread *thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1817         struct thread_trace *ttrace;
1818         size_t filename_len, entry_str_len, to_move;
1819         ssize_t remaining_space;
1820         char *pos;
1821         const char *filename = perf_evsel__rawptr(evsel, sample, "pathname");
1822
1823         if (!thread)
1824                 goto out;
1825
1826         ttrace = thread__priv(thread);
1827         if (!ttrace)
1828                 goto out_put;
1829
1830         filename_len = strlen(filename);
1831         if (filename_len == 0)
1832                 goto out_put;
1833
1834         if (ttrace->filename.namelen < filename_len) {
1835                 char *f = realloc(ttrace->filename.name, filename_len + 1);
1836
1837                 if (f == NULL)
1838                         goto out_put;
1839
1840                 ttrace->filename.namelen = filename_len;
1841                 ttrace->filename.name = f;
1842         }
1843
1844         strcpy(ttrace->filename.name, filename);
1845         ttrace->filename.pending_open = true;
1846
1847         if (!ttrace->filename.ptr)
1848                 goto out_put;
1849
1850         entry_str_len = strlen(ttrace->entry_str);
1851         remaining_space = trace__entry_str_size - entry_str_len - 1; /* \0 */
1852         if (remaining_space <= 0)
1853                 goto out_put;
1854
1855         if (filename_len > (size_t)remaining_space) {
1856                 filename += filename_len - remaining_space;
1857                 filename_len = remaining_space;
1858         }
1859
1860         to_move = entry_str_len - ttrace->filename.entry_str_pos + 1; /* \0 */
1861         pos = ttrace->entry_str + ttrace->filename.entry_str_pos;
1862         memmove(pos + filename_len, pos, to_move);
1863         memcpy(pos, filename, filename_len);
1864
1865         ttrace->filename.ptr = 0;
1866         ttrace->filename.entry_str_pos = 0;
1867 out_put:
1868         thread__put(thread);
1869 out:
1870         return 0;
1871 }
1872
1873 static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evsel,
1874                                      union perf_event *event __maybe_unused,
1875                                      struct perf_sample *sample)
1876 {
1877         u64 runtime = perf_evsel__intval(evsel, sample, "runtime");
1878         double runtime_ms = (double)runtime / NSEC_PER_MSEC;
1879         struct thread *thread = machine__findnew_thread(trace->host,
1880                                                         sample->pid,
1881                                                         sample->tid);
1882         struct thread_trace *ttrace = thread__trace(thread, trace->output);
1883
1884         if (ttrace == NULL)
1885                 goto out_dump;
1886
1887         ttrace->runtime_ms += runtime_ms;
1888         trace->runtime_ms += runtime_ms;
1889 out_put:
1890         thread__put(thread);
1891         return 0;
1892
1893 out_dump:
1894         fprintf(trace->output, "%s: comm=%s,pid=%u,runtime=%" PRIu64 ",vruntime=%" PRIu64 ")\n",
1895                evsel->name,
1896                perf_evsel__strval(evsel, sample, "comm"),
1897                (pid_t)perf_evsel__intval(evsel, sample, "pid"),
1898                runtime,
1899                perf_evsel__intval(evsel, sample, "vruntime"));
1900         goto out_put;
1901 }
1902
1903 static int bpf_output__printer(enum binary_printer_ops op,
1904                                unsigned int val, void *extra __maybe_unused, FILE *fp)
1905 {
1906         unsigned char ch = (unsigned char)val;
1907
1908         switch (op) {
1909         case BINARY_PRINT_CHAR_DATA:
1910                 return fprintf(fp, "%c", isprint(ch) ? ch : '.');
1911         case BINARY_PRINT_DATA_BEGIN:
1912         case BINARY_PRINT_LINE_BEGIN:
1913         case BINARY_PRINT_ADDR:
1914         case BINARY_PRINT_NUM_DATA:
1915         case BINARY_PRINT_NUM_PAD:
1916         case BINARY_PRINT_SEP:
1917         case BINARY_PRINT_CHAR_PAD:
1918         case BINARY_PRINT_LINE_END:
1919         case BINARY_PRINT_DATA_END:
1920         default:
1921                 break;
1922         }
1923
1924         return 0;
1925 }
1926
1927 static void bpf_output__fprintf(struct trace *trace,
1928                                 struct perf_sample *sample)
1929 {
1930         binary__fprintf(sample->raw_data, sample->raw_size, 8,
1931                         bpf_output__printer, NULL, trace->output);
1932 }
1933
1934 static int trace__event_handler(struct trace *trace, struct perf_evsel *evsel,
1935                                 union perf_event *event __maybe_unused,
1936                                 struct perf_sample *sample)
1937 {
1938         int callchain_ret = 0;
1939
1940         if (sample->callchain) {
1941                 callchain_ret = trace__resolve_callchain(trace, evsel, sample, &callchain_cursor);
1942                 if (callchain_ret == 0) {
1943                         if (callchain_cursor.nr < trace->min_stack)
1944                                 goto out;
1945                         callchain_ret = 1;
1946                 }
1947         }
1948
1949         trace__printf_interrupted_entry(trace);
1950         trace__fprintf_tstamp(trace, sample->time, trace->output);
1951
1952         if (trace->trace_syscalls)
1953                 fprintf(trace->output, "(         ): ");
1954
1955         fprintf(trace->output, "%s:", evsel->name);
1956
1957         if (perf_evsel__is_bpf_output(evsel)) {
1958                 bpf_output__fprintf(trace, sample);
1959         } else if (evsel->tp_format) {
1960                 event_format__fprintf(evsel->tp_format, sample->cpu,
1961                                       sample->raw_data, sample->raw_size,
1962                                       trace->output);
1963         }
1964
1965         fprintf(trace->output, "\n");
1966
1967         if (callchain_ret > 0)
1968                 trace__fprintf_callchain(trace, sample);
1969         else if (callchain_ret < 0)
1970                 pr_err("Problem processing %s callchain, skipping...\n", perf_evsel__name(evsel));
1971 out:
1972         return 0;
1973 }
1974
1975 static void print_location(FILE *f, struct perf_sample *sample,
1976                            struct addr_location *al,
1977                            bool print_dso, bool print_sym)
1978 {
1979
1980         if ((verbose > 0 || print_dso) && al->map)
1981                 fprintf(f, "%s@", al->map->dso->long_name);
1982
1983         if ((verbose > 0 || print_sym) && al->sym)
1984                 fprintf(f, "%s+0x%" PRIx64, al->sym->name,
1985                         al->addr - al->sym->start);
1986         else if (al->map)
1987                 fprintf(f, "0x%" PRIx64, al->addr);
1988         else
1989                 fprintf(f, "0x%" PRIx64, sample->addr);
1990 }
1991
1992 static int trace__pgfault(struct trace *trace,
1993                           struct perf_evsel *evsel,
1994                           union perf_event *event __maybe_unused,
1995                           struct perf_sample *sample)
1996 {
1997         struct thread *thread;
1998         struct addr_location al;
1999         char map_type = 'd';
2000         struct thread_trace *ttrace;
2001         int err = -1;
2002         int callchain_ret = 0;
2003
2004         thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
2005
2006         if (sample->callchain) {
2007                 callchain_ret = trace__resolve_callchain(trace, evsel, sample, &callchain_cursor);
2008                 if (callchain_ret == 0) {
2009                         if (callchain_cursor.nr < trace->min_stack)
2010                                 goto out_put;
2011                         callchain_ret = 1;
2012                 }
2013         }
2014
2015         ttrace = thread__trace(thread, trace->output);
2016         if (ttrace == NULL)
2017                 goto out_put;
2018
2019         if (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)
2020                 ttrace->pfmaj++;
2021         else
2022                 ttrace->pfmin++;
2023
2024         if (trace->summary_only)
2025                 goto out;
2026
2027         thread__find_addr_location(thread, sample->cpumode, MAP__FUNCTION,
2028                               sample->ip, &al);
2029
2030         trace__fprintf_entry_head(trace, thread, 0, true, sample->time, trace->output);
2031
2032         fprintf(trace->output, "%sfault [",
2033                 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ?
2034                 "maj" : "min");
2035
2036         print_location(trace->output, sample, &al, false, true);
2037
2038         fprintf(trace->output, "] => ");
2039
2040         thread__find_addr_location(thread, sample->cpumode, MAP__VARIABLE,
2041                                    sample->addr, &al);
2042
2043         if (!al.map) {
2044                 thread__find_addr_location(thread, sample->cpumode,
2045                                            MAP__FUNCTION, sample->addr, &al);
2046
2047                 if (al.map)
2048                         map_type = 'x';
2049                 else
2050                         map_type = '?';
2051         }
2052
2053         print_location(trace->output, sample, &al, true, false);
2054
2055         fprintf(trace->output, " (%c%c)\n", map_type, al.level);
2056
2057         if (callchain_ret > 0)
2058                 trace__fprintf_callchain(trace, sample);
2059         else if (callchain_ret < 0)
2060                 pr_err("Problem processing %s callchain, skipping...\n", perf_evsel__name(evsel));
2061 out:
2062         err = 0;
2063 out_put:
2064         thread__put(thread);
2065         return err;
2066 }
2067
2068 static void trace__set_base_time(struct trace *trace,
2069                                  struct perf_evsel *evsel,
2070                                  struct perf_sample *sample)
2071 {
2072         /*
2073          * BPF events were not setting PERF_SAMPLE_TIME, so be more robust
2074          * and don't use sample->time unconditionally, we may end up having
2075          * some other event in the future without PERF_SAMPLE_TIME for good
2076          * reason, i.e. we may not be interested in its timestamps, just in
2077          * it taking place, picking some piece of information when it
2078          * appears in our event stream (vfs_getname comes to mind).
2079          */
2080         if (trace->base_time == 0 && !trace->full_time &&
2081             (evsel->attr.sample_type & PERF_SAMPLE_TIME))
2082                 trace->base_time = sample->time;
2083 }
2084
2085 static int trace__process_sample(struct perf_tool *tool,
2086                                  union perf_event *event,
2087                                  struct perf_sample *sample,
2088                                  struct perf_evsel *evsel,
2089                                  struct machine *machine __maybe_unused)
2090 {
2091         struct trace *trace = container_of(tool, struct trace, tool);
2092         struct thread *thread;
2093         int err = 0;
2094
2095         tracepoint_handler handler = evsel->handler;
2096
2097         thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
2098         if (thread && thread__is_filtered(thread))
2099                 goto out;
2100
2101         trace__set_base_time(trace, evsel, sample);
2102
2103         if (handler) {
2104                 ++trace->nr_events;
2105                 handler(trace, evsel, event, sample);
2106         }
2107 out:
2108         thread__put(thread);
2109         return err;
2110 }
2111
2112 static int trace__record(struct trace *trace, int argc, const char **argv)
2113 {
2114         unsigned int rec_argc, i, j;
2115         const char **rec_argv;
2116         const char * const record_args[] = {
2117                 "record",
2118                 "-R",
2119                 "-m", "1024",
2120                 "-c", "1",
2121         };
2122
2123         const char * const sc_args[] = { "-e", };
2124         unsigned int sc_args_nr = ARRAY_SIZE(sc_args);
2125         const char * const majpf_args[] = { "-e", "major-faults" };
2126         unsigned int majpf_args_nr = ARRAY_SIZE(majpf_args);
2127         const char * const minpf_args[] = { "-e", "minor-faults" };
2128         unsigned int minpf_args_nr = ARRAY_SIZE(minpf_args);
2129
2130         /* +1 is for the event string below */
2131         rec_argc = ARRAY_SIZE(record_args) + sc_args_nr + 1 +
2132                 majpf_args_nr + minpf_args_nr + argc;
2133         rec_argv = calloc(rec_argc + 1, sizeof(char *));
2134
2135         if (rec_argv == NULL)
2136                 return -ENOMEM;
2137
2138         j = 0;
2139         for (i = 0; i < ARRAY_SIZE(record_args); i++)
2140                 rec_argv[j++] = record_args[i];
2141
2142         if (trace->trace_syscalls) {
2143                 for (i = 0; i < sc_args_nr; i++)
2144                         rec_argv[j++] = sc_args[i];
2145
2146                 /* event string may be different for older kernels - e.g., RHEL6 */
2147                 if (is_valid_tracepoint("raw_syscalls:sys_enter"))
2148                         rec_argv[j++] = "raw_syscalls:sys_enter,raw_syscalls:sys_exit";
2149                 else if (is_valid_tracepoint("syscalls:sys_enter"))
2150                         rec_argv[j++] = "syscalls:sys_enter,syscalls:sys_exit";
2151                 else {
2152                         pr_err("Neither raw_syscalls nor syscalls events exist.\n");
2153                         free(rec_argv);
2154                         return -1;
2155                 }
2156         }
2157
2158         if (trace->trace_pgfaults & TRACE_PFMAJ)
2159                 for (i = 0; i < majpf_args_nr; i++)
2160                         rec_argv[j++] = majpf_args[i];
2161
2162         if (trace->trace_pgfaults & TRACE_PFMIN)
2163                 for (i = 0; i < minpf_args_nr; i++)
2164                         rec_argv[j++] = minpf_args[i];
2165
2166         for (i = 0; i < (unsigned int)argc; i++)
2167                 rec_argv[j++] = argv[i];
2168
2169         return cmd_record(j, rec_argv);
2170 }
2171
2172 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp);
2173
2174 static bool perf_evlist__add_vfs_getname(struct perf_evlist *evlist)
2175 {
2176         struct perf_evsel *evsel = perf_evsel__newtp("probe", "vfs_getname");
2177
2178         if (IS_ERR(evsel))
2179                 return false;
2180
2181         if (perf_evsel__field(evsel, "pathname") == NULL) {
2182                 perf_evsel__delete(evsel);
2183                 return false;
2184         }
2185
2186         evsel->handler = trace__vfs_getname;
2187         perf_evlist__add(evlist, evsel);
2188         return true;
2189 }
2190
2191 static struct perf_evsel *perf_evsel__new_pgfault(u64 config)
2192 {
2193         struct perf_evsel *evsel;
2194         struct perf_event_attr attr = {
2195                 .type = PERF_TYPE_SOFTWARE,
2196                 .mmap_data = 1,
2197         };
2198
2199         attr.config = config;
2200         attr.sample_period = 1;
2201
2202         event_attr_init(&attr);
2203
2204         evsel = perf_evsel__new(&attr);
2205         if (evsel)
2206                 evsel->handler = trace__pgfault;
2207
2208         return evsel;
2209 }
2210
2211 static void trace__handle_event(struct trace *trace, union perf_event *event, struct perf_sample *sample)
2212 {
2213         const u32 type = event->header.type;
2214         struct perf_evsel *evsel;
2215
2216         if (type != PERF_RECORD_SAMPLE) {
2217                 trace__process_event(trace, trace->host, event, sample);
2218                 return;
2219         }
2220
2221         evsel = perf_evlist__id2evsel(trace->evlist, sample->id);
2222         if (evsel == NULL) {
2223                 fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample->id);
2224                 return;
2225         }
2226
2227         trace__set_base_time(trace, evsel, sample);
2228
2229         if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
2230             sample->raw_data == NULL) {
2231                 fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
2232                        perf_evsel__name(evsel), sample->tid,
2233                        sample->cpu, sample->raw_size);
2234         } else {
2235                 tracepoint_handler handler = evsel->handler;
2236                 handler(trace, evsel, event, sample);
2237         }
2238 }
2239
2240 static int trace__add_syscall_newtp(struct trace *trace)
2241 {
2242         int ret = -1;
2243         struct perf_evlist *evlist = trace->evlist;
2244         struct perf_evsel *sys_enter, *sys_exit;
2245
2246         sys_enter = perf_evsel__syscall_newtp("sys_enter", trace__sys_enter);
2247         if (sys_enter == NULL)
2248                 goto out;
2249
2250         if (perf_evsel__init_sc_tp_ptr_field(sys_enter, args))
2251                 goto out_delete_sys_enter;
2252
2253         sys_exit = perf_evsel__syscall_newtp("sys_exit", trace__sys_exit);
2254         if (sys_exit == NULL)
2255                 goto out_delete_sys_enter;
2256
2257         if (perf_evsel__init_sc_tp_uint_field(sys_exit, ret))
2258                 goto out_delete_sys_exit;
2259
2260         perf_evsel__config_callchain(sys_enter, &trace->opts, &callchain_param);
2261         perf_evsel__config_callchain(sys_exit, &trace->opts, &callchain_param);
2262
2263         perf_evlist__add(evlist, sys_enter);
2264         perf_evlist__add(evlist, sys_exit);
2265
2266         if (callchain_param.enabled && !trace->kernel_syscallchains) {
2267                 /*
2268                  * We're interested only in the user space callchain
2269                  * leading to the syscall, allow overriding that for
2270                  * debugging reasons using --kernel_syscall_callchains
2271                  */
2272                 sys_exit->attr.exclude_callchain_kernel = 1;
2273         }
2274
2275         trace->syscalls.events.sys_enter = sys_enter;
2276         trace->syscalls.events.sys_exit  = sys_exit;
2277
2278         ret = 0;
2279 out:
2280         return ret;
2281
2282 out_delete_sys_exit:
2283         perf_evsel__delete_priv(sys_exit);
2284 out_delete_sys_enter:
2285         perf_evsel__delete_priv(sys_enter);
2286         goto out;
2287 }
2288
2289 static int trace__set_ev_qualifier_filter(struct trace *trace)
2290 {
2291         int err = -1;
2292         struct perf_evsel *sys_exit;
2293         char *filter = asprintf_expr_inout_ints("id", !trace->not_ev_qualifier,
2294                                                 trace->ev_qualifier_ids.nr,
2295                                                 trace->ev_qualifier_ids.entries);
2296
2297         if (filter == NULL)
2298                 goto out_enomem;
2299
2300         if (!perf_evsel__append_tp_filter(trace->syscalls.events.sys_enter,
2301                                           filter)) {
2302                 sys_exit = trace->syscalls.events.sys_exit;
2303                 err = perf_evsel__append_tp_filter(sys_exit, filter);
2304         }
2305
2306         free(filter);
2307 out:
2308         return err;
2309 out_enomem:
2310         errno = ENOMEM;
2311         goto out;
2312 }
2313
2314 static int trace__set_filter_loop_pids(struct trace *trace)
2315 {
2316         unsigned int nr = 1;
2317         pid_t pids[32] = {
2318                 getpid(),
2319         };
2320         struct thread *thread = machine__find_thread(trace->host, pids[0], pids[0]);
2321
2322         while (thread && nr < ARRAY_SIZE(pids)) {
2323                 struct thread *parent = machine__find_thread(trace->host, thread->ppid, thread->ppid);
2324
2325                 if (parent == NULL)
2326                         break;
2327
2328                 if (!strcmp(thread__comm_str(parent), "sshd")) {
2329                         pids[nr++] = parent->tid;
2330                         break;
2331                 }
2332                 thread = parent;
2333         }
2334
2335         return perf_evlist__set_filter_pids(trace->evlist, nr, pids);
2336 }
2337
2338 static int trace__run(struct trace *trace, int argc, const char **argv)
2339 {
2340         struct perf_evlist *evlist = trace->evlist;
2341         struct perf_evsel *evsel, *pgfault_maj = NULL, *pgfault_min = NULL;
2342         int err = -1, i;
2343         unsigned long before;
2344         const bool forks = argc > 0;
2345         bool draining = false;
2346
2347         trace->live = true;
2348
2349         if (trace->trace_syscalls && trace__add_syscall_newtp(trace))
2350                 goto out_error_raw_syscalls;
2351
2352         if (trace->trace_syscalls)
2353                 trace->vfs_getname = perf_evlist__add_vfs_getname(evlist);
2354
2355         if ((trace->trace_pgfaults & TRACE_PFMAJ)) {
2356                 pgfault_maj = perf_evsel__new_pgfault(PERF_COUNT_SW_PAGE_FAULTS_MAJ);
2357                 if (pgfault_maj == NULL)
2358                         goto out_error_mem;
2359                 perf_evsel__config_callchain(pgfault_maj, &trace->opts, &callchain_param);
2360                 perf_evlist__add(evlist, pgfault_maj);
2361         }
2362
2363         if ((trace->trace_pgfaults & TRACE_PFMIN)) {
2364                 pgfault_min = perf_evsel__new_pgfault(PERF_COUNT_SW_PAGE_FAULTS_MIN);
2365                 if (pgfault_min == NULL)
2366                         goto out_error_mem;
2367                 perf_evsel__config_callchain(pgfault_min, &trace->opts, &callchain_param);
2368                 perf_evlist__add(evlist, pgfault_min);
2369         }
2370
2371         if (trace->sched &&
2372             perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
2373                                    trace__sched_stat_runtime))
2374                 goto out_error_sched_stat_runtime;
2375
2376         /*
2377          * If a global cgroup was set, apply it to all the events without an
2378          * explicit cgroup. I.e.:
2379          *
2380          *      trace -G A -e sched:*switch
2381          *
2382          * Will set all raw_syscalls:sys_{enter,exit}, pgfault, vfs_getname, etc
2383          * _and_ sched:sched_switch to the 'A' cgroup, while:
2384          *
2385          * trace -e sched:*switch -G A
2386          *
2387          * will only set the sched:sched_switch event to the 'A' cgroup, all the
2388          * other events (raw_syscalls:sys_{enter,exit}, etc are left "without"
2389          * a cgroup (on the root cgroup, sys wide, etc).
2390          *
2391          * Multiple cgroups:
2392          *
2393          * trace -G A -e sched:*switch -G B
2394          *
2395          * the syscall ones go to the 'A' cgroup, the sched:sched_switch goes
2396          * to the 'B' cgroup.
2397          *
2398          * evlist__set_default_cgroup() grabs a reference of the passed cgroup
2399          * only for the evsels still without a cgroup, i.e. evsel->cgroup == NULL.
2400          */
2401         if (trace->cgroup)
2402                 evlist__set_default_cgroup(trace->evlist, trace->cgroup);
2403
2404         err = perf_evlist__create_maps(evlist, &trace->opts.target);
2405         if (err < 0) {
2406                 fprintf(trace->output, "Problems parsing the target to trace, check your options!\n");
2407                 goto out_delete_evlist;
2408         }
2409
2410         err = trace__symbols_init(trace, evlist);
2411         if (err < 0) {
2412                 fprintf(trace->output, "Problems initializing symbol libraries!\n");
2413                 goto out_delete_evlist;
2414         }
2415
2416         perf_evlist__config(evlist, &trace->opts, &callchain_param);
2417
2418         signal(SIGCHLD, sig_handler);
2419         signal(SIGINT, sig_handler);
2420
2421         if (forks) {
2422                 err = perf_evlist__prepare_workload(evlist, &trace->opts.target,
2423                                                     argv, false, NULL);
2424                 if (err < 0) {
2425                         fprintf(trace->output, "Couldn't run the workload!\n");
2426                         goto out_delete_evlist;
2427                 }
2428         }
2429
2430         err = perf_evlist__open(evlist);
2431         if (err < 0)
2432                 goto out_error_open;
2433
2434         err = bpf__apply_obj_config();
2435         if (err) {
2436                 char errbuf[BUFSIZ];
2437
2438                 bpf__strerror_apply_obj_config(err, errbuf, sizeof(errbuf));
2439                 pr_err("ERROR: Apply config to BPF failed: %s\n",
2440                          errbuf);
2441                 goto out_error_open;
2442         }
2443
2444         /*
2445          * Better not use !target__has_task() here because we need to cover the
2446          * case where no threads were specified in the command line, but a
2447          * workload was, and in that case we will fill in the thread_map when
2448          * we fork the workload in perf_evlist__prepare_workload.
2449          */
2450         if (trace->filter_pids.nr > 0)
2451                 err = perf_evlist__set_filter_pids(evlist, trace->filter_pids.nr, trace->filter_pids.entries);
2452         else if (thread_map__pid(evlist->threads, 0) == -1)
2453                 err = trace__set_filter_loop_pids(trace);
2454
2455         if (err < 0)
2456                 goto out_error_mem;
2457
2458         if (trace->ev_qualifier_ids.nr > 0) {
2459                 err = trace__set_ev_qualifier_filter(trace);
2460                 if (err < 0)
2461                         goto out_errno;
2462
2463                 pr_debug("event qualifier tracepoint filter: %s\n",
2464                          trace->syscalls.events.sys_exit->filter);
2465         }
2466
2467         err = perf_evlist__apply_filters(evlist, &evsel);
2468         if (err < 0)
2469                 goto out_error_apply_filters;
2470
2471         err = perf_evlist__mmap(evlist, trace->opts.mmap_pages);
2472         if (err < 0)
2473                 goto out_error_mmap;
2474
2475         if (!target__none(&trace->opts.target) && !trace->opts.initial_delay)
2476                 perf_evlist__enable(evlist);
2477
2478         if (forks)
2479                 perf_evlist__start_workload(evlist);
2480
2481         if (trace->opts.initial_delay) {
2482                 usleep(trace->opts.initial_delay * 1000);
2483                 perf_evlist__enable(evlist);
2484         }
2485
2486         trace->multiple_threads = thread_map__pid(evlist->threads, 0) == -1 ||
2487                                   evlist->threads->nr > 1 ||
2488                                   perf_evlist__first(evlist)->attr.inherit;
2489
2490         /*
2491          * Now that we already used evsel->attr to ask the kernel to setup the
2492          * events, lets reuse evsel->attr.sample_max_stack as the limit in
2493          * trace__resolve_callchain(), allowing per-event max-stack settings
2494          * to override an explicitely set --max-stack global setting.
2495          */
2496         evlist__for_each_entry(evlist, evsel) {
2497                 if ((evsel->attr.sample_type & PERF_SAMPLE_CALLCHAIN) &&
2498                     evsel->attr.sample_max_stack == 0)
2499                         evsel->attr.sample_max_stack = trace->max_stack;
2500         }
2501 again:
2502         before = trace->nr_events;
2503
2504         for (i = 0; i < evlist->nr_mmaps; i++) {
2505                 union perf_event *event;
2506                 struct perf_mmap *md;
2507
2508                 md = &evlist->mmap[i];
2509                 if (perf_mmap__read_init(md) < 0)
2510                         continue;
2511
2512                 while ((event = perf_mmap__read_event(md)) != NULL) {
2513                         struct perf_sample sample;
2514
2515                         ++trace->nr_events;
2516
2517                         err = perf_evlist__parse_sample(evlist, event, &sample);
2518                         if (err) {
2519                                 fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);
2520                                 goto next_event;
2521                         }
2522
2523                         trace__handle_event(trace, event, &sample);
2524 next_event:
2525                         perf_mmap__consume(md);
2526
2527                         if (interrupted)
2528                                 goto out_disable;
2529
2530                         if (done && !draining) {
2531                                 perf_evlist__disable(evlist);
2532                                 draining = true;
2533                         }
2534                 }
2535                 perf_mmap__read_done(md);
2536         }
2537
2538         if (trace->nr_events == before) {
2539                 int timeout = done ? 100 : -1;
2540
2541                 if (!draining && perf_evlist__poll(evlist, timeout) > 0) {
2542                         if (perf_evlist__filter_pollfd(evlist, POLLERR | POLLHUP) == 0)
2543                                 draining = true;
2544
2545                         goto again;
2546                 }
2547         } else {
2548                 goto again;
2549         }
2550
2551 out_disable:
2552         thread__zput(trace->current);
2553
2554         perf_evlist__disable(evlist);
2555
2556         if (!err) {
2557                 if (trace->summary)
2558                         trace__fprintf_thread_summary(trace, trace->output);
2559
2560                 if (trace->show_tool_stats) {
2561                         fprintf(trace->output, "Stats:\n "
2562                                                " vfs_getname : %" PRIu64 "\n"
2563                                                " proc_getname: %" PRIu64 "\n",
2564                                 trace->stats.vfs_getname,
2565                                 trace->stats.proc_getname);
2566                 }
2567         }
2568
2569 out_delete_evlist:
2570         trace__symbols__exit(trace);
2571
2572         perf_evlist__delete(evlist);
2573         cgroup__put(trace->cgroup);
2574         trace->evlist = NULL;
2575         trace->live = false;
2576         return err;
2577 {
2578         char errbuf[BUFSIZ];
2579
2580 out_error_sched_stat_runtime:
2581         tracing_path__strerror_open_tp(errno, errbuf, sizeof(errbuf), "sched", "sched_stat_runtime");
2582         goto out_error;
2583
2584 out_error_raw_syscalls:
2585         tracing_path__strerror_open_tp(errno, errbuf, sizeof(errbuf), "raw_syscalls", "sys_(enter|exit)");
2586         goto out_error;
2587
2588 out_error_mmap:
2589         perf_evlist__strerror_mmap(evlist, errno, errbuf, sizeof(errbuf));
2590         goto out_error;
2591
2592 out_error_open:
2593         perf_evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
2594
2595 out_error:
2596         fprintf(trace->output, "%s\n", errbuf);
2597         goto out_delete_evlist;
2598
2599 out_error_apply_filters:
2600         fprintf(trace->output,
2601                 "Failed to set filter \"%s\" on event %s with %d (%s)\n",
2602                 evsel->filter, perf_evsel__name(evsel), errno,
2603                 str_error_r(errno, errbuf, sizeof(errbuf)));
2604         goto out_delete_evlist;
2605 }
2606 out_error_mem:
2607         fprintf(trace->output, "Not enough memory to run!\n");
2608         goto out_delete_evlist;
2609
2610 out_errno:
2611         fprintf(trace->output, "errno=%d,%s\n", errno, strerror(errno));
2612         goto out_delete_evlist;
2613 }
2614
2615 static int trace__replay(struct trace *trace)
2616 {
2617         const struct perf_evsel_str_handler handlers[] = {
2618                 { "probe:vfs_getname",       trace__vfs_getname, },
2619         };
2620         struct perf_data data = {
2621                 .file      = {
2622                         .path = input_name,
2623                 },
2624                 .mode      = PERF_DATA_MODE_READ,
2625                 .force     = trace->force,
2626         };
2627         struct perf_session *session;
2628         struct perf_evsel *evsel;
2629         int err = -1;
2630
2631         trace->tool.sample        = trace__process_sample;
2632         trace->tool.mmap          = perf_event__process_mmap;
2633         trace->tool.mmap2         = perf_event__process_mmap2;
2634         trace->tool.comm          = perf_event__process_comm;
2635         trace->tool.exit          = perf_event__process_exit;
2636         trace->tool.fork          = perf_event__process_fork;
2637         trace->tool.attr          = perf_event__process_attr;
2638         trace->tool.tracing_data  = perf_event__process_tracing_data;
2639         trace->tool.build_id      = perf_event__process_build_id;
2640         trace->tool.namespaces    = perf_event__process_namespaces;
2641
2642         trace->tool.ordered_events = true;
2643         trace->tool.ordering_requires_timestamps = true;
2644
2645         /* add tid to output */
2646         trace->multiple_threads = true;
2647
2648         session = perf_session__new(&data, false, &trace->tool);
2649         if (session == NULL)
2650                 return -1;
2651
2652         if (trace->opts.target.pid)
2653                 symbol_conf.pid_list_str = strdup(trace->opts.target.pid);
2654
2655         if (trace->opts.target.tid)
2656                 symbol_conf.tid_list_str = strdup(trace->opts.target.tid);
2657
2658         if (symbol__init(&session->header.env) < 0)
2659                 goto out;
2660
2661         trace->host = &session->machines.host;
2662
2663         err = perf_session__set_tracepoints_handlers(session, handlers);
2664         if (err)
2665                 goto out;
2666
2667         evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2668                                                      "raw_syscalls:sys_enter");
2669         /* older kernels have syscalls tp versus raw_syscalls */
2670         if (evsel == NULL)
2671                 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2672                                                              "syscalls:sys_enter");
2673
2674         if (evsel &&
2675             (perf_evsel__init_syscall_tp(evsel, trace__sys_enter) < 0 ||
2676             perf_evsel__init_sc_tp_ptr_field(evsel, args))) {
2677                 pr_err("Error during initialize raw_syscalls:sys_enter event\n");
2678                 goto out;
2679         }
2680
2681         evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2682                                                      "raw_syscalls:sys_exit");
2683         if (evsel == NULL)
2684                 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2685                                                              "syscalls:sys_exit");
2686         if (evsel &&
2687             (perf_evsel__init_syscall_tp(evsel, trace__sys_exit) < 0 ||
2688             perf_evsel__init_sc_tp_uint_field(evsel, ret))) {
2689                 pr_err("Error during initialize raw_syscalls:sys_exit event\n");
2690                 goto out;
2691         }
2692
2693         evlist__for_each_entry(session->evlist, evsel) {
2694                 if (evsel->attr.type == PERF_TYPE_SOFTWARE &&
2695                     (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ||
2696                      evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MIN ||
2697                      evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS))
2698                         evsel->handler = trace__pgfault;
2699         }
2700
2701         setup_pager();
2702
2703         err = perf_session__process_events(session);
2704         if (err)
2705                 pr_err("Failed to process events, error %d", err);
2706
2707         else if (trace->summary)
2708                 trace__fprintf_thread_summary(trace, trace->output);
2709
2710 out:
2711         perf_session__delete(session);
2712
2713         return err;
2714 }
2715
2716 static size_t trace__fprintf_threads_header(FILE *fp)
2717 {
2718         size_t printed;
2719
2720         printed  = fprintf(fp, "\n Summary of events:\n\n");
2721
2722         return printed;
2723 }
2724
2725 DEFINE_RESORT_RB(syscall_stats, a->msecs > b->msecs,
2726         struct stats    *stats;
2727         double          msecs;
2728         int             syscall;
2729 )
2730 {
2731         struct int_node *source = rb_entry(nd, struct int_node, rb_node);
2732         struct stats *stats = source->priv;
2733
2734         entry->syscall = source->i;
2735         entry->stats   = stats;
2736         entry->msecs   = stats ? (u64)stats->n * (avg_stats(stats) / NSEC_PER_MSEC) : 0;
2737 }
2738
2739 static size_t thread__dump_stats(struct thread_trace *ttrace,
2740                                  struct trace *trace, FILE *fp)
2741 {
2742         size_t printed = 0;
2743         struct syscall *sc;
2744         struct rb_node *nd;
2745         DECLARE_RESORT_RB_INTLIST(syscall_stats, ttrace->syscall_stats);
2746
2747         if (syscall_stats == NULL)
2748                 return 0;
2749
2750         printed += fprintf(fp, "\n");
2751
2752         printed += fprintf(fp, "   syscall            calls    total       min       avg       max      stddev\n");
2753         printed += fprintf(fp, "                               (msec)    (msec)    (msec)    (msec)        (%%)\n");
2754         printed += fprintf(fp, "   --------------- -------- --------- --------- --------- ---------     ------\n");
2755
2756         resort_rb__for_each_entry(nd, syscall_stats) {
2757                 struct stats *stats = syscall_stats_entry->stats;
2758                 if (stats) {
2759                         double min = (double)(stats->min) / NSEC_PER_MSEC;
2760                         double max = (double)(stats->max) / NSEC_PER_MSEC;
2761                         double avg = avg_stats(stats);
2762                         double pct;
2763                         u64 n = (u64) stats->n;
2764
2765                         pct = avg ? 100.0 * stddev_stats(stats)/avg : 0.0;
2766                         avg /= NSEC_PER_MSEC;
2767
2768                         sc = &trace->syscalls.table[syscall_stats_entry->syscall];
2769                         printed += fprintf(fp, "   %-15s", sc->name);
2770                         printed += fprintf(fp, " %8" PRIu64 " %9.3f %9.3f %9.3f",
2771                                            n, syscall_stats_entry->msecs, min, avg);
2772                         printed += fprintf(fp, " %9.3f %9.2f%%\n", max, pct);
2773                 }
2774         }
2775
2776         resort_rb__delete(syscall_stats);
2777         printed += fprintf(fp, "\n\n");
2778
2779         return printed;
2780 }
2781
2782 static size_t trace__fprintf_thread(FILE *fp, struct thread *thread, struct trace *trace)
2783 {
2784         size_t printed = 0;
2785         struct thread_trace *ttrace = thread__priv(thread);
2786         double ratio;
2787
2788         if (ttrace == NULL)
2789                 return 0;
2790
2791         ratio = (double)ttrace->nr_events / trace->nr_events * 100.0;
2792
2793         printed += fprintf(fp, " %s (%d), ", thread__comm_str(thread), thread->tid);
2794         printed += fprintf(fp, "%lu events, ", ttrace->nr_events);
2795         printed += fprintf(fp, "%.1f%%", ratio);
2796         if (ttrace->pfmaj)
2797                 printed += fprintf(fp, ", %lu majfaults", ttrace->pfmaj);
2798         if (ttrace->pfmin)
2799                 printed += fprintf(fp, ", %lu minfaults", ttrace->pfmin);
2800         if (trace->sched)
2801                 printed += fprintf(fp, ", %.3f msec\n", ttrace->runtime_ms);
2802         else if (fputc('\n', fp) != EOF)
2803                 ++printed;
2804
2805         printed += thread__dump_stats(ttrace, trace, fp);
2806
2807         return printed;
2808 }
2809
2810 static unsigned long thread__nr_events(struct thread_trace *ttrace)
2811 {
2812         return ttrace ? ttrace->nr_events : 0;
2813 }
2814
2815 DEFINE_RESORT_RB(threads, (thread__nr_events(a->thread->priv) < thread__nr_events(b->thread->priv)),
2816         struct thread *thread;
2817 )
2818 {
2819         entry->thread = rb_entry(nd, struct thread, rb_node);
2820 }
2821
2822 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
2823 {
2824         size_t printed = trace__fprintf_threads_header(fp);
2825         struct rb_node *nd;
2826         int i;
2827
2828         for (i = 0; i < THREADS__TABLE_SIZE; i++) {
2829                 DECLARE_RESORT_RB_MACHINE_THREADS(threads, trace->host, i);
2830
2831                 if (threads == NULL) {
2832                         fprintf(fp, "%s", "Error sorting output by nr_events!\n");
2833                         return 0;
2834                 }
2835
2836                 resort_rb__for_each_entry(nd, threads)
2837                         printed += trace__fprintf_thread(fp, threads_entry->thread, trace);
2838
2839                 resort_rb__delete(threads);
2840         }
2841         return printed;
2842 }
2843
2844 static int trace__set_duration(const struct option *opt, const char *str,
2845                                int unset __maybe_unused)
2846 {
2847         struct trace *trace = opt->value;
2848
2849         trace->duration_filter = atof(str);
2850         return 0;
2851 }
2852
2853 static int trace__set_filter_pids(const struct option *opt, const char *str,
2854                                   int unset __maybe_unused)
2855 {
2856         int ret = -1;
2857         size_t i;
2858         struct trace *trace = opt->value;
2859         /*
2860          * FIXME: introduce a intarray class, plain parse csv and create a
2861          * { int nr, int entries[] } struct...
2862          */
2863         struct intlist *list = intlist__new(str);
2864
2865         if (list == NULL)
2866                 return -1;
2867
2868         i = trace->filter_pids.nr = intlist__nr_entries(list) + 1;
2869         trace->filter_pids.entries = calloc(i, sizeof(pid_t));
2870
2871         if (trace->filter_pids.entries == NULL)
2872                 goto out;
2873
2874         trace->filter_pids.entries[0] = getpid();
2875
2876         for (i = 1; i < trace->filter_pids.nr; ++i)
2877                 trace->filter_pids.entries[i] = intlist__entry(list, i - 1)->i;
2878
2879         intlist__delete(list);
2880         ret = 0;
2881 out:
2882         return ret;
2883 }
2884
2885 static int trace__open_output(struct trace *trace, const char *filename)
2886 {
2887         struct stat st;
2888
2889         if (!stat(filename, &st) && st.st_size) {
2890                 char oldname[PATH_MAX];
2891
2892                 scnprintf(oldname, sizeof(oldname), "%s.old", filename);
2893                 unlink(oldname);
2894                 rename(filename, oldname);
2895         }
2896
2897         trace->output = fopen(filename, "w");
2898
2899         return trace->output == NULL ? -errno : 0;
2900 }
2901
2902 static int parse_pagefaults(const struct option *opt, const char *str,
2903                             int unset __maybe_unused)
2904 {
2905         int *trace_pgfaults = opt->value;
2906
2907         if (strcmp(str, "all") == 0)
2908                 *trace_pgfaults |= TRACE_PFMAJ | TRACE_PFMIN;
2909         else if (strcmp(str, "maj") == 0)
2910                 *trace_pgfaults |= TRACE_PFMAJ;
2911         else if (strcmp(str, "min") == 0)
2912                 *trace_pgfaults |= TRACE_PFMIN;
2913         else
2914                 return -1;
2915
2916         return 0;
2917 }
2918
2919 static void evlist__set_evsel_handler(struct perf_evlist *evlist, void *handler)
2920 {
2921         struct perf_evsel *evsel;
2922
2923         evlist__for_each_entry(evlist, evsel)
2924                 evsel->handler = handler;
2925 }
2926
2927 /*
2928  * XXX: Hackish, just splitting the combined -e+--event (syscalls
2929  * (raw_syscalls:{sys_{enter,exit}} + events (tracepoints, HW, SW, etc) to use
2930  * existing facilities unchanged (trace->ev_qualifier + parse_options()).
2931  *
2932  * It'd be better to introduce a parse_options() variant that would return a
2933  * list with the terms it didn't match to an event...
2934  */
2935 static int trace__parse_events_option(const struct option *opt, const char *str,
2936                                       int unset __maybe_unused)
2937 {
2938         struct trace *trace = (struct trace *)opt->value;
2939         const char *s = str;
2940         char *sep = NULL, *lists[2] = { NULL, NULL, };
2941         int len = strlen(str) + 1, err = -1, list, idx;
2942         char *strace_groups_dir = system_path(STRACE_GROUPS_DIR);
2943         char group_name[PATH_MAX];
2944
2945         if (strace_groups_dir == NULL)
2946                 return -1;
2947
2948         if (*s == '!') {
2949                 ++s;
2950                 trace->not_ev_qualifier = true;
2951         }
2952
2953         while (1) {
2954                 if ((sep = strchr(s, ',')) != NULL)
2955                         *sep = '\0';
2956
2957                 list = 0;
2958                 if (syscalltbl__id(trace->sctbl, s) >= 0 ||
2959                     syscalltbl__strglobmatch_first(trace->sctbl, s, &idx) >= 0) {
2960                         list = 1;
2961                 } else {
2962                         path__join(group_name, sizeof(group_name), strace_groups_dir, s);
2963                         if (access(group_name, R_OK) == 0)
2964                                 list = 1;
2965                 }
2966
2967                 if (lists[list]) {
2968                         sprintf(lists[list] + strlen(lists[list]), ",%s", s);
2969                 } else {
2970                         lists[list] = malloc(len);
2971                         if (lists[list] == NULL)
2972                                 goto out;
2973                         strcpy(lists[list], s);
2974                 }
2975
2976                 if (!sep)
2977                         break;
2978
2979                 *sep = ',';
2980                 s = sep + 1;
2981         }
2982
2983         if (lists[1] != NULL) {
2984                 struct strlist_config slist_config = {
2985                         .dirname = strace_groups_dir,
2986                 };
2987
2988                 trace->ev_qualifier = strlist__new(lists[1], &slist_config);
2989                 if (trace->ev_qualifier == NULL) {
2990                         fputs("Not enough memory to parse event qualifier", trace->output);
2991                         goto out;
2992                 }
2993
2994                 if (trace__validate_ev_qualifier(trace))
2995                         goto out;
2996         }
2997
2998         err = 0;
2999
3000         if (lists[0]) {
3001                 struct option o = OPT_CALLBACK('e', "event", &trace->evlist, "event",
3002                                                "event selector. use 'perf list' to list available events",
3003                                                parse_events_option);
3004                 err = parse_events_option(&o, lists[0], 0);
3005         }
3006 out:
3007         if (sep)
3008                 *sep = ',';
3009
3010         return err;
3011 }
3012
3013 static int trace__parse_cgroups(const struct option *opt, const char *str, int unset)
3014 {
3015         struct trace *trace = opt->value;
3016
3017         if (!list_empty(&trace->evlist->entries))
3018                 return parse_cgroups(opt, str, unset);
3019
3020         trace->cgroup = evlist__findnew_cgroup(trace->evlist, str);
3021
3022         return 0;
3023 }
3024
3025 int cmd_trace(int argc, const char **argv)
3026 {
3027         const char *trace_usage[] = {
3028                 "perf trace [<options>] [<command>]",
3029                 "perf trace [<options>] -- <command> [<options>]",
3030                 "perf trace record [<options>] [<command>]",
3031                 "perf trace record [<options>] -- <command> [<options>]",
3032                 NULL
3033         };
3034         struct trace trace = {
3035                 .syscalls = {
3036                         . max = -1,
3037                 },
3038                 .opts = {
3039                         .target = {
3040                                 .uid       = UINT_MAX,
3041                                 .uses_mmap = true,
3042                         },
3043                         .user_freq     = UINT_MAX,
3044                         .user_interval = ULLONG_MAX,
3045                         .no_buffering  = true,
3046                         .mmap_pages    = UINT_MAX,
3047                         .proc_map_timeout  = 500,
3048                 },
3049                 .output = stderr,
3050                 .show_comm = true,
3051                 .trace_syscalls = true,
3052                 .kernel_syscallchains = false,
3053                 .max_stack = UINT_MAX,
3054         };
3055         const char *output_name = NULL;
3056         const struct option trace_options[] = {
3057         OPT_CALLBACK('e', "event", &trace, "event",
3058                      "event/syscall selector. use 'perf list' to list available events",
3059                      trace__parse_events_option),
3060         OPT_BOOLEAN(0, "comm", &trace.show_comm,
3061                     "show the thread COMM next to its id"),
3062         OPT_BOOLEAN(0, "tool_stats", &trace.show_tool_stats, "show tool stats"),
3063         OPT_CALLBACK(0, "expr", &trace, "expr", "list of syscalls/events to trace",
3064                      trace__parse_events_option),
3065         OPT_STRING('o', "output", &output_name, "file", "output file name"),
3066         OPT_STRING('i', "input", &input_name, "file", "Analyze events in file"),
3067         OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
3068                     "trace events on existing process id"),
3069         OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
3070                     "trace events on existing thread id"),
3071         OPT_CALLBACK(0, "filter-pids", &trace, "CSV list of pids",
3072                      "pids to filter (by the kernel)", trace__set_filter_pids),
3073         OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
3074                     "system-wide collection from all CPUs"),
3075         OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
3076                     "list of cpus to monitor"),
3077         OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
3078                     "child tasks do not inherit counters"),
3079         OPT_CALLBACK('m', "mmap-pages", &trace.opts.mmap_pages, "pages",
3080                      "number of mmap data pages",
3081                      perf_evlist__parse_mmap_pages),
3082         OPT_STRING('u', "uid", &trace.opts.target.uid_str, "user",
3083                    "user to profile"),
3084         OPT_CALLBACK(0, "duration", &trace, "float",
3085                      "show only events with duration > N.M ms",
3086                      trace__set_duration),
3087         OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),
3088         OPT_INCR('v', "verbose", &verbose, "be more verbose"),
3089         OPT_BOOLEAN('T', "time", &trace.full_time,
3090                     "Show full timestamp, not time relative to first start"),
3091         OPT_BOOLEAN(0, "failure", &trace.failure_only,
3092                     "Show only syscalls that failed"),
3093         OPT_BOOLEAN('s', "summary", &trace.summary_only,
3094                     "Show only syscall summary with statistics"),
3095         OPT_BOOLEAN('S', "with-summary", &trace.summary,
3096                     "Show all syscalls and summary with statistics"),
3097         OPT_CALLBACK_DEFAULT('F', "pf", &trace.trace_pgfaults, "all|maj|min",
3098                      "Trace pagefaults", parse_pagefaults, "maj"),
3099         OPT_BOOLEAN(0, "syscalls", &trace.trace_syscalls, "Trace syscalls"),
3100         OPT_BOOLEAN('f', "force", &trace.force, "don't complain, do it"),
3101         OPT_CALLBACK(0, "call-graph", &trace.opts,
3102                      "record_mode[,record_size]", record_callchain_help,
3103                      &record_parse_callchain_opt),
3104         OPT_BOOLEAN(0, "kernel-syscall-graph", &trace.kernel_syscallchains,
3105                     "Show the kernel callchains on the syscall exit path"),
3106         OPT_UINTEGER(0, "min-stack", &trace.min_stack,
3107                      "Set the minimum stack depth when parsing the callchain, "
3108                      "anything below the specified depth will be ignored."),
3109         OPT_UINTEGER(0, "max-stack", &trace.max_stack,
3110                      "Set the maximum stack depth when parsing the callchain, "
3111                      "anything beyond the specified depth will be ignored. "
3112                      "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)),
3113         OPT_BOOLEAN(0, "print-sample", &trace.print_sample,
3114                         "print the PERF_RECORD_SAMPLE PERF_SAMPLE_ info, for debugging"),
3115         OPT_UINTEGER(0, "proc-map-timeout", &trace.opts.proc_map_timeout,
3116                         "per thread proc mmap processing timeout in ms"),
3117         OPT_CALLBACK('G', "cgroup", &trace, "name", "monitor event in cgroup name only",
3118                      trace__parse_cgroups),
3119         OPT_UINTEGER('D', "delay", &trace.opts.initial_delay,
3120                      "ms to wait before starting measurement after program "
3121                      "start"),
3122         OPT_END()
3123         };
3124         bool __maybe_unused max_stack_user_set = true;
3125         bool mmap_pages_user_set = true;
3126         const char * const trace_subcommands[] = { "record", NULL };
3127         int err;
3128         char bf[BUFSIZ];
3129
3130         signal(SIGSEGV, sighandler_dump_stack);
3131         signal(SIGFPE, sighandler_dump_stack);
3132
3133         trace.evlist = perf_evlist__new();
3134         trace.sctbl = syscalltbl__new();
3135
3136         if (trace.evlist == NULL || trace.sctbl == NULL) {
3137                 pr_err("Not enough memory to run!\n");
3138                 err = -ENOMEM;
3139                 goto out;
3140         }
3141
3142         argc = parse_options_subcommand(argc, argv, trace_options, trace_subcommands,
3143                                  trace_usage, PARSE_OPT_STOP_AT_NON_OPTION);
3144
3145         if ((nr_cgroups || trace.cgroup) && !trace.opts.target.system_wide) {
3146                 usage_with_options_msg(trace_usage, trace_options,
3147                                        "cgroup monitoring only available in system-wide mode");
3148         }
3149
3150         err = bpf__setup_stdout(trace.evlist);
3151         if (err) {
3152                 bpf__strerror_setup_stdout(trace.evlist, err, bf, sizeof(bf));
3153                 pr_err("ERROR: Setup BPF stdout failed: %s\n", bf);
3154                 goto out;
3155         }
3156
3157         err = -1;
3158
3159         if (trace.trace_pgfaults) {
3160                 trace.opts.sample_address = true;
3161                 trace.opts.sample_time = true;
3162         }
3163
3164         if (trace.opts.mmap_pages == UINT_MAX)
3165                 mmap_pages_user_set = false;
3166
3167         if (trace.max_stack == UINT_MAX) {
3168                 trace.max_stack = input_name ? PERF_MAX_STACK_DEPTH : sysctl_perf_event_max_stack;
3169                 max_stack_user_set = false;
3170         }
3171
3172 #ifdef HAVE_DWARF_UNWIND_SUPPORT
3173         if ((trace.min_stack || max_stack_user_set) && !callchain_param.enabled) {
3174                 record_opts__parse_callchain(&trace.opts, &callchain_param, "dwarf", false);
3175         }
3176 #endif
3177
3178         if (callchain_param.enabled) {
3179                 if (!mmap_pages_user_set && geteuid() == 0)
3180                         trace.opts.mmap_pages = perf_event_mlock_kb_in_pages() * 4;
3181
3182                 symbol_conf.use_callchain = true;
3183         }
3184
3185         if (trace.evlist->nr_entries > 0)
3186                 evlist__set_evsel_handler(trace.evlist, trace__event_handler);
3187
3188         if ((argc >= 1) && (strcmp(argv[0], "record") == 0))
3189                 return trace__record(&trace, argc-1, &argv[1]);
3190
3191         /* summary_only implies summary option, but don't overwrite summary if set */
3192         if (trace.summary_only)
3193                 trace.summary = trace.summary_only;
3194
3195         if (!trace.trace_syscalls && !trace.trace_pgfaults &&
3196             trace.evlist->nr_entries == 0 /* Was --events used? */) {
3197                 pr_err("Please specify something to trace.\n");
3198                 return -1;
3199         }
3200
3201         if (!trace.trace_syscalls && trace.ev_qualifier) {
3202                 pr_err("The -e option can't be used with --no-syscalls.\n");
3203                 goto out;
3204         }
3205
3206         if (output_name != NULL) {
3207                 err = trace__open_output(&trace, output_name);
3208                 if (err < 0) {
3209                         perror("failed to create output file");
3210                         goto out;
3211                 }
3212         }
3213
3214         trace.open_id = syscalltbl__id(trace.sctbl, "open");
3215
3216         err = target__validate(&trace.opts.target);
3217         if (err) {
3218                 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
3219                 fprintf(trace.output, "%s", bf);
3220                 goto out_close;
3221         }
3222
3223         err = target__parse_uid(&trace.opts.target);
3224         if (err) {
3225                 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
3226                 fprintf(trace.output, "%s", bf);
3227                 goto out_close;
3228         }
3229
3230         if (!argc && target__none(&trace.opts.target))
3231                 trace.opts.target.system_wide = true;
3232
3233         if (input_name)
3234                 err = trace__replay(&trace);
3235         else
3236                 err = trace__run(&trace, argc, argv);
3237
3238 out_close:
3239         if (output_name != NULL)
3240                 fclose(trace.output);
3241 out:
3242         return err;
3243 }