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