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 void trace__symbols__exit(struct trace *trace)
1142 {
1143         machine__exit(trace->host);
1144         trace->host = NULL;
1145
1146         symbol__exit();
1147 }
1148
1149 static int syscall__alloc_arg_fmts(struct syscall *sc, int nr_args)
1150 {
1151         int idx;
1152
1153         if (nr_args == 6 && sc->fmt && sc->fmt->nr_args != 0)
1154                 nr_args = sc->fmt->nr_args;
1155
1156         sc->arg_fmt = calloc(nr_args, sizeof(*sc->arg_fmt));
1157         if (sc->arg_fmt == NULL)
1158                 return -1;
1159
1160         for (idx = 0; idx < nr_args; ++idx) {
1161                 if (sc->fmt)
1162                         sc->arg_fmt[idx] = sc->fmt->arg[idx];
1163         }
1164
1165         sc->nr_args = nr_args;
1166         return 0;
1167 }
1168
1169 static int syscall__set_arg_fmts(struct syscall *sc)
1170 {
1171         struct format_field *field;
1172         int idx = 0, len;
1173
1174         for (field = sc->args; field; field = field->next, ++idx) {
1175                 if (sc->fmt && sc->fmt->arg[idx].scnprintf)
1176                         continue;
1177
1178                 if (strcmp(field->type, "const char *") == 0 &&
1179                          (strcmp(field->name, "filename") == 0 ||
1180                           strcmp(field->name, "path") == 0 ||
1181                           strcmp(field->name, "pathname") == 0))
1182                         sc->arg_fmt[idx].scnprintf = SCA_FILENAME;
1183                 else if (field->flags & FIELD_IS_POINTER)
1184                         sc->arg_fmt[idx].scnprintf = syscall_arg__scnprintf_hex;
1185                 else if (strcmp(field->type, "pid_t") == 0)
1186                         sc->arg_fmt[idx].scnprintf = SCA_PID;
1187                 else if (strcmp(field->type, "umode_t") == 0)
1188                         sc->arg_fmt[idx].scnprintf = SCA_MODE_T;
1189                 else if ((strcmp(field->type, "int") == 0 ||
1190                           strcmp(field->type, "unsigned int") == 0 ||
1191                           strcmp(field->type, "long") == 0) &&
1192                          (len = strlen(field->name)) >= 2 &&
1193                          strcmp(field->name + len - 2, "fd") == 0) {
1194                         /*
1195                          * /sys/kernel/tracing/events/syscalls/sys_enter*
1196                          * egrep 'field:.*fd;' .../format|sed -r 's/.*field:([a-z ]+) [a-z_]*fd.+/\1/g'|sort|uniq -c
1197                          * 65 int
1198                          * 23 unsigned int
1199                          * 7 unsigned long
1200                          */
1201                         sc->arg_fmt[idx].scnprintf = SCA_FD;
1202                 }
1203         }
1204
1205         return 0;
1206 }
1207
1208 static int trace__read_syscall_info(struct trace *trace, int id)
1209 {
1210         char tp_name[128];
1211         struct syscall *sc;
1212         const char *name = syscalltbl__name(trace->sctbl, id);
1213
1214         if (name == NULL)
1215                 return -1;
1216
1217         if (id > trace->syscalls.max) {
1218                 struct syscall *nsyscalls = realloc(trace->syscalls.table, (id + 1) * sizeof(*sc));
1219
1220                 if (nsyscalls == NULL)
1221                         return -1;
1222
1223                 if (trace->syscalls.max != -1) {
1224                         memset(nsyscalls + trace->syscalls.max + 1, 0,
1225                                (id - trace->syscalls.max) * sizeof(*sc));
1226                 } else {
1227                         memset(nsyscalls, 0, (id + 1) * sizeof(*sc));
1228                 }
1229
1230                 trace->syscalls.table = nsyscalls;
1231                 trace->syscalls.max   = id;
1232         }
1233
1234         sc = trace->syscalls.table + id;
1235         sc->name = name;
1236
1237         sc->fmt  = syscall_fmt__find(sc->name);
1238
1239         snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->name);
1240         sc->tp_format = trace_event__tp_format("syscalls", tp_name);
1241
1242         if (IS_ERR(sc->tp_format) && sc->fmt && sc->fmt->alias) {
1243                 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->fmt->alias);
1244                 sc->tp_format = trace_event__tp_format("syscalls", tp_name);
1245         }
1246
1247         if (syscall__alloc_arg_fmts(sc, IS_ERR(sc->tp_format) ? 6 : sc->tp_format->format.nr_fields))
1248                 return -1;
1249
1250         if (IS_ERR(sc->tp_format))
1251                 return -1;
1252
1253         sc->args = sc->tp_format->format.fields;
1254         /*
1255          * We need to check and discard the first variable '__syscall_nr'
1256          * or 'nr' that mean the syscall number. It is needless here.
1257          * So drop '__syscall_nr' or 'nr' field but does not exist on older kernels.
1258          */
1259         if (sc->args && (!strcmp(sc->args->name, "__syscall_nr") || !strcmp(sc->args->name, "nr"))) {
1260                 sc->args = sc->args->next;
1261                 --sc->nr_args;
1262         }
1263
1264         sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
1265
1266         return syscall__set_arg_fmts(sc);
1267 }
1268
1269 static int trace__validate_ev_qualifier(struct trace *trace)
1270 {
1271         int err = 0, i;
1272         size_t nr_allocated;
1273         struct str_node *pos;
1274
1275         trace->ev_qualifier_ids.nr = strlist__nr_entries(trace->ev_qualifier);
1276         trace->ev_qualifier_ids.entries = malloc(trace->ev_qualifier_ids.nr *
1277                                                  sizeof(trace->ev_qualifier_ids.entries[0]));
1278
1279         if (trace->ev_qualifier_ids.entries == NULL) {
1280                 fputs("Error:\tNot enough memory for allocating events qualifier ids\n",
1281                        trace->output);
1282                 err = -EINVAL;
1283                 goto out;
1284         }
1285
1286         nr_allocated = trace->ev_qualifier_ids.nr;
1287         i = 0;
1288
1289         strlist__for_each_entry(pos, trace->ev_qualifier) {
1290                 const char *sc = pos->s;
1291                 int id = syscalltbl__id(trace->sctbl, sc), match_next = -1;
1292
1293                 if (id < 0) {
1294                         id = syscalltbl__strglobmatch_first(trace->sctbl, sc, &match_next);
1295                         if (id >= 0)
1296                                 goto matches;
1297
1298                         if (err == 0) {
1299                                 fputs("Error:\tInvalid syscall ", trace->output);
1300                                 err = -EINVAL;
1301                         } else {
1302                                 fputs(", ", trace->output);
1303                         }
1304
1305                         fputs(sc, trace->output);
1306                 }
1307 matches:
1308                 trace->ev_qualifier_ids.entries[i++] = id;
1309                 if (match_next == -1)
1310                         continue;
1311
1312                 while (1) {
1313                         id = syscalltbl__strglobmatch_next(trace->sctbl, sc, &match_next);
1314                         if (id < 0)
1315                                 break;
1316                         if (nr_allocated == trace->ev_qualifier_ids.nr) {
1317                                 void *entries;
1318
1319                                 nr_allocated += 8;
1320                                 entries = realloc(trace->ev_qualifier_ids.entries,
1321                                                   nr_allocated * sizeof(trace->ev_qualifier_ids.entries[0]));
1322                                 if (entries == NULL) {
1323                                         err = -ENOMEM;
1324                                         fputs("\nError:\t Not enough memory for parsing\n", trace->output);
1325                                         goto out_free;
1326                                 }
1327                                 trace->ev_qualifier_ids.entries = entries;
1328                         }
1329                         trace->ev_qualifier_ids.nr++;
1330                         trace->ev_qualifier_ids.entries[i++] = id;
1331                 }
1332         }
1333
1334         if (err < 0) {
1335                 fputs("\nHint:\ttry 'perf list syscalls:sys_enter_*'"
1336                       "\nHint:\tand: 'man syscalls'\n", trace->output);
1337 out_free:
1338                 zfree(&trace->ev_qualifier_ids.entries);
1339                 trace->ev_qualifier_ids.nr = 0;
1340         }
1341 out:
1342         return err;
1343 }
1344
1345 /*
1346  * args is to be interpreted as a series of longs but we need to handle
1347  * 8-byte unaligned accesses. args points to raw_data within the event
1348  * and raw_data is guaranteed to be 8-byte unaligned because it is
1349  * preceded by raw_size which is a u32. So we need to copy args to a temp
1350  * variable to read it. Most notably this avoids extended load instructions
1351  * on unaligned addresses
1352  */
1353 unsigned long syscall_arg__val(struct syscall_arg *arg, u8 idx)
1354 {
1355         unsigned long val;
1356         unsigned char *p = arg->args + sizeof(unsigned long) * idx;
1357
1358         memcpy(&val, p, sizeof(val));
1359         return val;
1360 }
1361
1362 static size_t syscall__scnprintf_name(struct syscall *sc, char *bf, size_t size,
1363                                       struct syscall_arg *arg)
1364 {
1365         if (sc->arg_fmt && sc->arg_fmt[arg->idx].name)
1366                 return scnprintf(bf, size, "%s: ", sc->arg_fmt[arg->idx].name);
1367
1368         return scnprintf(bf, size, "arg%d: ", arg->idx);
1369 }
1370
1371 static size_t syscall__scnprintf_val(struct syscall *sc, char *bf, size_t size,
1372                                      struct syscall_arg *arg, unsigned long val)
1373 {
1374         if (sc->arg_fmt && sc->arg_fmt[arg->idx].scnprintf) {
1375                 arg->val = val;
1376                 if (sc->arg_fmt[arg->idx].parm)
1377                         arg->parm = sc->arg_fmt[arg->idx].parm;
1378                 return sc->arg_fmt[arg->idx].scnprintf(bf, size, arg);
1379         }
1380         return scnprintf(bf, size, "%ld", val);
1381 }
1382
1383 static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
1384                                       unsigned char *args, struct trace *trace,
1385                                       struct thread *thread)
1386 {
1387         size_t printed = 0;
1388         unsigned long val;
1389         u8 bit = 1;
1390         struct syscall_arg arg = {
1391                 .args   = args,
1392                 .idx    = 0,
1393                 .mask   = 0,
1394                 .trace  = trace,
1395                 .thread = thread,
1396         };
1397         struct thread_trace *ttrace = thread__priv(thread);
1398
1399         /*
1400          * Things like fcntl will set this in its 'cmd' formatter to pick the
1401          * right formatter for the return value (an fd? file flags?), which is
1402          * not needed for syscalls that always return a given type, say an fd.
1403          */
1404         ttrace->ret_scnprintf = NULL;
1405
1406         if (sc->args != NULL) {
1407                 struct format_field *field;
1408
1409                 for (field = sc->args; field;
1410                      field = field->next, ++arg.idx, bit <<= 1) {
1411                         if (arg.mask & bit)
1412                                 continue;
1413
1414                         val = syscall_arg__val(&arg, arg.idx);
1415
1416                         /*
1417                          * Suppress this argument if its value is zero and
1418                          * and we don't have a string associated in an
1419                          * strarray for it.
1420                          */
1421                         if (val == 0 &&
1422                             !(sc->arg_fmt &&
1423                               (sc->arg_fmt[arg.idx].show_zero ||
1424                                sc->arg_fmt[arg.idx].scnprintf == SCA_STRARRAY ||
1425                                sc->arg_fmt[arg.idx].scnprintf == SCA_STRARRAYS) &&
1426                               sc->arg_fmt[arg.idx].parm))
1427                                 continue;
1428
1429                         printed += scnprintf(bf + printed, size - printed,
1430                                              "%s%s: ", printed ? ", " : "", field->name);
1431                         printed += syscall__scnprintf_val(sc, bf + printed, size - printed, &arg, val);
1432                 }
1433         } else if (IS_ERR(sc->tp_format)) {
1434                 /*
1435                  * If we managed to read the tracepoint /format file, then we
1436                  * may end up not having any args, like with gettid(), so only
1437                  * print the raw args when we didn't manage to read it.
1438                  */
1439                 while (arg.idx < sc->nr_args) {
1440                         if (arg.mask & bit)
1441                                 goto next_arg;
1442                         val = syscall_arg__val(&arg, arg.idx);
1443                         if (printed)
1444                                 printed += scnprintf(bf + printed, size - printed, ", ");
1445                         printed += syscall__scnprintf_name(sc, bf + printed, size - printed, &arg);
1446                         printed += syscall__scnprintf_val(sc, bf + printed, size - printed, &arg, val);
1447 next_arg:
1448                         ++arg.idx;
1449                         bit <<= 1;
1450                 }
1451         }
1452
1453         return printed;
1454 }
1455
1456 typedef int (*tracepoint_handler)(struct trace *trace, struct perf_evsel *evsel,
1457                                   union perf_event *event,
1458                                   struct perf_sample *sample);
1459
1460 static struct syscall *trace__syscall_info(struct trace *trace,
1461                                            struct perf_evsel *evsel, int id)
1462 {
1463
1464         if (id < 0) {
1465
1466                 /*
1467                  * XXX: Noticed on x86_64, reproduced as far back as 3.0.36, haven't tried
1468                  * before that, leaving at a higher verbosity level till that is
1469                  * explained. Reproduced with plain ftrace with:
1470                  *
1471                  * echo 1 > /t/events/raw_syscalls/sys_exit/enable
1472                  * grep "NR -1 " /t/trace_pipe
1473                  *
1474                  * After generating some load on the machine.
1475                  */
1476                 if (verbose > 1) {
1477                         static u64 n;
1478                         fprintf(trace->output, "Invalid syscall %d id, skipping (%s, %" PRIu64 ") ...\n",
1479                                 id, perf_evsel__name(evsel), ++n);
1480                 }
1481                 return NULL;
1482         }
1483
1484         if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL) &&
1485             trace__read_syscall_info(trace, id))
1486                 goto out_cant_read;
1487
1488         if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL))
1489                 goto out_cant_read;
1490
1491         return &trace->syscalls.table[id];
1492
1493 out_cant_read:
1494         if (verbose > 0) {
1495                 fprintf(trace->output, "Problems reading syscall %d", id);
1496                 if (id <= trace->syscalls.max && trace->syscalls.table[id].name != NULL)
1497                         fprintf(trace->output, "(%s)", trace->syscalls.table[id].name);
1498                 fputs(" information\n", trace->output);
1499         }
1500         return NULL;
1501 }
1502
1503 static void thread__update_stats(struct thread_trace *ttrace,
1504                                  int id, struct perf_sample *sample)
1505 {
1506         struct int_node *inode;
1507         struct stats *stats;
1508         u64 duration = 0;
1509
1510         inode = intlist__findnew(ttrace->syscall_stats, id);
1511         if (inode == NULL)
1512                 return;
1513
1514         stats = inode->priv;
1515         if (stats == NULL) {
1516                 stats = malloc(sizeof(struct stats));
1517                 if (stats == NULL)
1518                         return;
1519                 init_stats(stats);
1520                 inode->priv = stats;
1521         }
1522
1523         if (ttrace->entry_time && sample->time > ttrace->entry_time)
1524                 duration = sample->time - ttrace->entry_time;
1525
1526         update_stats(stats, duration);
1527 }
1528
1529 static int trace__printf_interrupted_entry(struct trace *trace, struct perf_sample *sample)
1530 {
1531         struct thread_trace *ttrace;
1532         u64 duration;
1533         size_t printed;
1534
1535         if (trace->current == NULL)
1536                 return 0;
1537
1538         ttrace = thread__priv(trace->current);
1539
1540         if (!ttrace->entry_pending)
1541                 return 0;
1542
1543         duration = sample->time - ttrace->entry_time;
1544
1545         printed  = trace__fprintf_entry_head(trace, trace->current, duration, true, ttrace->entry_time, trace->output);
1546         printed += fprintf(trace->output, "%-70s) ...\n", ttrace->entry_str);
1547         ttrace->entry_pending = false;
1548
1549         return printed;
1550 }
1551
1552 static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
1553                             union perf_event *event __maybe_unused,
1554                             struct perf_sample *sample)
1555 {
1556         char *msg;
1557         void *args;
1558         size_t printed = 0;
1559         struct thread *thread;
1560         int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1;
1561         struct syscall *sc = trace__syscall_info(trace, evsel, id);
1562         struct thread_trace *ttrace;
1563
1564         if (sc == NULL)
1565                 return -1;
1566
1567         thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1568         ttrace = thread__trace(thread, trace->output);
1569         if (ttrace == NULL)
1570                 goto out_put;
1571
1572         args = perf_evsel__sc_tp_ptr(evsel, args, sample);
1573
1574         if (ttrace->entry_str == NULL) {
1575                 ttrace->entry_str = malloc(trace__entry_str_size);
1576                 if (!ttrace->entry_str)
1577                         goto out_put;
1578         }
1579
1580         if (!(trace->duration_filter || trace->summary_only || trace->min_stack))
1581                 trace__printf_interrupted_entry(trace, sample);
1582
1583         ttrace->entry_time = sample->time;
1584         msg = ttrace->entry_str;
1585         printed += scnprintf(msg + printed, trace__entry_str_size - printed, "%s(", sc->name);
1586
1587         printed += syscall__scnprintf_args(sc, msg + printed, trace__entry_str_size - printed,
1588                                            args, trace, thread);
1589
1590         if (sc->is_exit) {
1591                 if (!(trace->duration_filter || trace->summary_only || trace->min_stack)) {
1592                         trace__fprintf_entry_head(trace, thread, 0, false, ttrace->entry_time, trace->output);
1593                         fprintf(trace->output, "%-70s)\n", ttrace->entry_str);
1594                 }
1595         } else {
1596                 ttrace->entry_pending = true;
1597                 /* See trace__vfs_getname & trace__sys_exit */
1598                 ttrace->filename.pending_open = false;
1599         }
1600
1601         if (trace->current != thread) {
1602                 thread__put(trace->current);
1603                 trace->current = thread__get(thread);
1604         }
1605         err = 0;
1606 out_put:
1607         thread__put(thread);
1608         return err;
1609 }
1610
1611 static int trace__resolve_callchain(struct trace *trace, struct perf_evsel *evsel,
1612                                     struct perf_sample *sample,
1613                                     struct callchain_cursor *cursor)
1614 {
1615         struct addr_location al;
1616
1617         if (machine__resolve(trace->host, &al, sample) < 0 ||
1618             thread__resolve_callchain(al.thread, cursor, evsel, sample, NULL, NULL, trace->max_stack))
1619                 return -1;
1620
1621         return 0;
1622 }
1623
1624 static int trace__fprintf_callchain(struct trace *trace, struct perf_sample *sample)
1625 {
1626         /* TODO: user-configurable print_opts */
1627         const unsigned int print_opts = EVSEL__PRINT_SYM |
1628                                         EVSEL__PRINT_DSO |
1629                                         EVSEL__PRINT_UNKNOWN_AS_ADDR;
1630
1631         return sample__fprintf_callchain(sample, 38, print_opts, &callchain_cursor, trace->output);
1632 }
1633
1634 static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
1635                            union perf_event *event __maybe_unused,
1636                            struct perf_sample *sample)
1637 {
1638         long ret;
1639         u64 duration = 0;
1640         bool duration_calculated = false;
1641         struct thread *thread;
1642         int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1, callchain_ret = 0;
1643         struct syscall *sc = trace__syscall_info(trace, evsel, id);
1644         struct thread_trace *ttrace;
1645
1646         if (sc == NULL)
1647                 return -1;
1648
1649         thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1650         ttrace = thread__trace(thread, trace->output);
1651         if (ttrace == NULL)
1652                 goto out_put;
1653
1654         if (trace->summary)
1655                 thread__update_stats(ttrace, id, sample);
1656
1657         ret = perf_evsel__sc_tp_uint(evsel, ret, sample);
1658
1659         if (id == trace->open_id && ret >= 0 && ttrace->filename.pending_open) {
1660                 trace__set_fd_pathname(thread, ret, ttrace->filename.name);
1661                 ttrace->filename.pending_open = false;
1662                 ++trace->stats.vfs_getname;
1663         }
1664
1665         if (ttrace->entry_time) {
1666                 duration = sample->time - ttrace->entry_time;
1667                 if (trace__filter_duration(trace, duration))
1668                         goto out;
1669                 duration_calculated = true;
1670         } else if (trace->duration_filter)
1671                 goto out;
1672
1673         if (sample->callchain) {
1674                 callchain_ret = trace__resolve_callchain(trace, evsel, sample, &callchain_cursor);
1675                 if (callchain_ret == 0) {
1676                         if (callchain_cursor.nr < trace->min_stack)
1677                                 goto out;
1678                         callchain_ret = 1;
1679                 }
1680         }
1681
1682         if (trace->summary_only)
1683                 goto out;
1684
1685         trace__fprintf_entry_head(trace, thread, duration, duration_calculated, ttrace->entry_time, trace->output);
1686
1687         if (ttrace->entry_pending) {
1688                 fprintf(trace->output, "%-70s", ttrace->entry_str);
1689         } else {
1690                 fprintf(trace->output, " ... [");
1691                 color_fprintf(trace->output, PERF_COLOR_YELLOW, "continued");
1692                 fprintf(trace->output, "]: %s()", sc->name);
1693         }
1694
1695         if (sc->fmt == NULL) {
1696                 if (ret < 0)
1697                         goto errno_print;
1698 signed_print:
1699                 fprintf(trace->output, ") = %ld", ret);
1700         } else if (ret < 0) {
1701 errno_print: {
1702                 char bf[STRERR_BUFSIZE];
1703                 const char *emsg = str_error_r(-ret, bf, sizeof(bf)),
1704                            *e = audit_errno_to_name(-ret);
1705
1706                 fprintf(trace->output, ") = -1 %s %s", e, emsg);
1707         }
1708         } else if (ret == 0 && sc->fmt->timeout)
1709                 fprintf(trace->output, ") = 0 Timeout");
1710         else if (ttrace->ret_scnprintf) {
1711                 char bf[1024];
1712                 struct syscall_arg arg = {
1713                         .val    = ret,
1714                         .thread = thread,
1715                         .trace  = trace,
1716                 };
1717                 ttrace->ret_scnprintf(bf, sizeof(bf), &arg);
1718                 ttrace->ret_scnprintf = NULL;
1719                 fprintf(trace->output, ") = %s", bf);
1720         } else if (sc->fmt->hexret)
1721                 fprintf(trace->output, ") = %#lx", ret);
1722         else if (sc->fmt->errpid) {
1723                 struct thread *child = machine__find_thread(trace->host, ret, ret);
1724
1725                 if (child != NULL) {
1726                         fprintf(trace->output, ") = %ld", ret);
1727                         if (child->comm_set)
1728                                 fprintf(trace->output, " (%s)", thread__comm_str(child));
1729                         thread__put(child);
1730                 }
1731         } else
1732                 goto signed_print;
1733
1734         fputc('\n', trace->output);
1735
1736         if (callchain_ret > 0)
1737                 trace__fprintf_callchain(trace, sample);
1738         else if (callchain_ret < 0)
1739                 pr_err("Problem processing %s callchain, skipping...\n", perf_evsel__name(evsel));
1740 out:
1741         ttrace->entry_pending = false;
1742         err = 0;
1743 out_put:
1744         thread__put(thread);
1745         return err;
1746 }
1747
1748 static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
1749                               union perf_event *event __maybe_unused,
1750                               struct perf_sample *sample)
1751 {
1752         struct thread *thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1753         struct thread_trace *ttrace;
1754         size_t filename_len, entry_str_len, to_move;
1755         ssize_t remaining_space;
1756         char *pos;
1757         const char *filename = perf_evsel__rawptr(evsel, sample, "pathname");
1758
1759         if (!thread)
1760                 goto out;
1761
1762         ttrace = thread__priv(thread);
1763         if (!ttrace)
1764                 goto out_put;
1765
1766         filename_len = strlen(filename);
1767         if (filename_len == 0)
1768                 goto out_put;
1769
1770         if (ttrace->filename.namelen < filename_len) {
1771                 char *f = realloc(ttrace->filename.name, filename_len + 1);
1772
1773                 if (f == NULL)
1774                         goto out_put;
1775
1776                 ttrace->filename.namelen = filename_len;
1777                 ttrace->filename.name = f;
1778         }
1779
1780         strcpy(ttrace->filename.name, filename);
1781         ttrace->filename.pending_open = true;
1782
1783         if (!ttrace->filename.ptr)
1784                 goto out_put;
1785
1786         entry_str_len = strlen(ttrace->entry_str);
1787         remaining_space = trace__entry_str_size - entry_str_len - 1; /* \0 */
1788         if (remaining_space <= 0)
1789                 goto out_put;
1790
1791         if (filename_len > (size_t)remaining_space) {
1792                 filename += filename_len - remaining_space;
1793                 filename_len = remaining_space;
1794         }
1795
1796         to_move = entry_str_len - ttrace->filename.entry_str_pos + 1; /* \0 */
1797         pos = ttrace->entry_str + ttrace->filename.entry_str_pos;
1798         memmove(pos + filename_len, pos, to_move);
1799         memcpy(pos, filename, filename_len);
1800
1801         ttrace->filename.ptr = 0;
1802         ttrace->filename.entry_str_pos = 0;
1803 out_put:
1804         thread__put(thread);
1805 out:
1806         return 0;
1807 }
1808
1809 static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evsel,
1810                                      union perf_event *event __maybe_unused,
1811                                      struct perf_sample *sample)
1812 {
1813         u64 runtime = perf_evsel__intval(evsel, sample, "runtime");
1814         double runtime_ms = (double)runtime / NSEC_PER_MSEC;
1815         struct thread *thread = machine__findnew_thread(trace->host,
1816                                                         sample->pid,
1817                                                         sample->tid);
1818         struct thread_trace *ttrace = thread__trace(thread, trace->output);
1819
1820         if (ttrace == NULL)
1821                 goto out_dump;
1822
1823         ttrace->runtime_ms += runtime_ms;
1824         trace->runtime_ms += runtime_ms;
1825 out_put:
1826         thread__put(thread);
1827         return 0;
1828
1829 out_dump:
1830         fprintf(trace->output, "%s: comm=%s,pid=%u,runtime=%" PRIu64 ",vruntime=%" PRIu64 ")\n",
1831                evsel->name,
1832                perf_evsel__strval(evsel, sample, "comm"),
1833                (pid_t)perf_evsel__intval(evsel, sample, "pid"),
1834                runtime,
1835                perf_evsel__intval(evsel, sample, "vruntime"));
1836         goto out_put;
1837 }
1838
1839 static void bpf_output__printer(enum binary_printer_ops op,
1840                                 unsigned int val, void *extra)
1841 {
1842         FILE *output = extra;
1843         unsigned char ch = (unsigned char)val;
1844
1845         switch (op) {
1846         case BINARY_PRINT_CHAR_DATA:
1847                 fprintf(output, "%c", isprint(ch) ? ch : '.');
1848                 break;
1849         case BINARY_PRINT_DATA_BEGIN:
1850         case BINARY_PRINT_LINE_BEGIN:
1851         case BINARY_PRINT_ADDR:
1852         case BINARY_PRINT_NUM_DATA:
1853         case BINARY_PRINT_NUM_PAD:
1854         case BINARY_PRINT_SEP:
1855         case BINARY_PRINT_CHAR_PAD:
1856         case BINARY_PRINT_LINE_END:
1857         case BINARY_PRINT_DATA_END:
1858         default:
1859                 break;
1860         }
1861 }
1862
1863 static void bpf_output__fprintf(struct trace *trace,
1864                                 struct perf_sample *sample)
1865 {
1866         print_binary(sample->raw_data, sample->raw_size, 8,
1867                      bpf_output__printer, trace->output);
1868 }
1869
1870 static int trace__event_handler(struct trace *trace, struct perf_evsel *evsel,
1871                                 union perf_event *event __maybe_unused,
1872                                 struct perf_sample *sample)
1873 {
1874         int callchain_ret = 0;
1875
1876         if (sample->callchain) {
1877                 callchain_ret = trace__resolve_callchain(trace, evsel, sample, &callchain_cursor);
1878                 if (callchain_ret == 0) {
1879                         if (callchain_cursor.nr < trace->min_stack)
1880                                 goto out;
1881                         callchain_ret = 1;
1882                 }
1883         }
1884
1885         trace__printf_interrupted_entry(trace, sample);
1886         trace__fprintf_tstamp(trace, sample->time, trace->output);
1887
1888         if (trace->trace_syscalls)
1889                 fprintf(trace->output, "(         ): ");
1890
1891         fprintf(trace->output, "%s:", evsel->name);
1892
1893         if (perf_evsel__is_bpf_output(evsel)) {
1894                 bpf_output__fprintf(trace, sample);
1895         } else if (evsel->tp_format) {
1896                 event_format__fprintf(evsel->tp_format, sample->cpu,
1897                                       sample->raw_data, sample->raw_size,
1898                                       trace->output);
1899         }
1900
1901         fprintf(trace->output, ")\n");
1902
1903         if (callchain_ret > 0)
1904                 trace__fprintf_callchain(trace, sample);
1905         else if (callchain_ret < 0)
1906                 pr_err("Problem processing %s callchain, skipping...\n", perf_evsel__name(evsel));
1907 out:
1908         return 0;
1909 }
1910
1911 static void print_location(FILE *f, struct perf_sample *sample,
1912                            struct addr_location *al,
1913                            bool print_dso, bool print_sym)
1914 {
1915
1916         if ((verbose > 0 || print_dso) && al->map)
1917                 fprintf(f, "%s@", al->map->dso->long_name);
1918
1919         if ((verbose > 0 || print_sym) && al->sym)
1920                 fprintf(f, "%s+0x%" PRIx64, al->sym->name,
1921                         al->addr - al->sym->start);
1922         else if (al->map)
1923                 fprintf(f, "0x%" PRIx64, al->addr);
1924         else
1925                 fprintf(f, "0x%" PRIx64, sample->addr);
1926 }
1927
1928 static int trace__pgfault(struct trace *trace,
1929                           struct perf_evsel *evsel,
1930                           union perf_event *event __maybe_unused,
1931                           struct perf_sample *sample)
1932 {
1933         struct thread *thread;
1934         struct addr_location al;
1935         char map_type = 'd';
1936         struct thread_trace *ttrace;
1937         int err = -1;
1938         int callchain_ret = 0;
1939
1940         thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1941
1942         if (sample->callchain) {
1943                 callchain_ret = trace__resolve_callchain(trace, evsel, sample, &callchain_cursor);
1944                 if (callchain_ret == 0) {
1945                         if (callchain_cursor.nr < trace->min_stack)
1946                                 goto out_put;
1947                         callchain_ret = 1;
1948                 }
1949         }
1950
1951         ttrace = thread__trace(thread, trace->output);
1952         if (ttrace == NULL)
1953                 goto out_put;
1954
1955         if (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)
1956                 ttrace->pfmaj++;
1957         else
1958                 ttrace->pfmin++;
1959
1960         if (trace->summary_only)
1961                 goto out;
1962
1963         thread__find_addr_location(thread, sample->cpumode, MAP__FUNCTION,
1964                               sample->ip, &al);
1965
1966         trace__fprintf_entry_head(trace, thread, 0, true, sample->time, trace->output);
1967
1968         fprintf(trace->output, "%sfault [",
1969                 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ?
1970                 "maj" : "min");
1971
1972         print_location(trace->output, sample, &al, false, true);
1973
1974         fprintf(trace->output, "] => ");
1975
1976         thread__find_addr_location(thread, sample->cpumode, MAP__VARIABLE,
1977                                    sample->addr, &al);
1978
1979         if (!al.map) {
1980                 thread__find_addr_location(thread, sample->cpumode,
1981                                            MAP__FUNCTION, sample->addr, &al);
1982
1983                 if (al.map)
1984                         map_type = 'x';
1985                 else
1986                         map_type = '?';
1987         }
1988
1989         print_location(trace->output, sample, &al, true, false);
1990
1991         fprintf(trace->output, " (%c%c)\n", map_type, al.level);
1992
1993         if (callchain_ret > 0)
1994                 trace__fprintf_callchain(trace, sample);
1995         else if (callchain_ret < 0)
1996                 pr_err("Problem processing %s callchain, skipping...\n", perf_evsel__name(evsel));
1997 out:
1998         err = 0;
1999 out_put:
2000         thread__put(thread);
2001         return err;
2002 }
2003
2004 static void trace__set_base_time(struct trace *trace,
2005                                  struct perf_evsel *evsel,
2006                                  struct perf_sample *sample)
2007 {
2008         /*
2009          * BPF events were not setting PERF_SAMPLE_TIME, so be more robust
2010          * and don't use sample->time unconditionally, we may end up having
2011          * some other event in the future without PERF_SAMPLE_TIME for good
2012          * reason, i.e. we may not be interested in its timestamps, just in
2013          * it taking place, picking some piece of information when it
2014          * appears in our event stream (vfs_getname comes to mind).
2015          */
2016         if (trace->base_time == 0 && !trace->full_time &&
2017             (evsel->attr.sample_type & PERF_SAMPLE_TIME))
2018                 trace->base_time = sample->time;
2019 }
2020
2021 static int trace__process_sample(struct perf_tool *tool,
2022                                  union perf_event *event,
2023                                  struct perf_sample *sample,
2024                                  struct perf_evsel *evsel,
2025                                  struct machine *machine __maybe_unused)
2026 {
2027         struct trace *trace = container_of(tool, struct trace, tool);
2028         struct thread *thread;
2029         int err = 0;
2030
2031         tracepoint_handler handler = evsel->handler;
2032
2033         thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
2034         if (thread && thread__is_filtered(thread))
2035                 goto out;
2036
2037         trace__set_base_time(trace, evsel, sample);
2038
2039         if (handler) {
2040                 ++trace->nr_events;
2041                 handler(trace, evsel, event, sample);
2042         }
2043 out:
2044         thread__put(thread);
2045         return err;
2046 }
2047
2048 static int trace__record(struct trace *trace, int argc, const char **argv)
2049 {
2050         unsigned int rec_argc, i, j;
2051         const char **rec_argv;
2052         const char * const record_args[] = {
2053                 "record",
2054                 "-R",
2055                 "-m", "1024",
2056                 "-c", "1",
2057         };
2058
2059         const char * const sc_args[] = { "-e", };
2060         unsigned int sc_args_nr = ARRAY_SIZE(sc_args);
2061         const char * const majpf_args[] = { "-e", "major-faults" };
2062         unsigned int majpf_args_nr = ARRAY_SIZE(majpf_args);
2063         const char * const minpf_args[] = { "-e", "minor-faults" };
2064         unsigned int minpf_args_nr = ARRAY_SIZE(minpf_args);
2065
2066         /* +1 is for the event string below */
2067         rec_argc = ARRAY_SIZE(record_args) + sc_args_nr + 1 +
2068                 majpf_args_nr + minpf_args_nr + argc;
2069         rec_argv = calloc(rec_argc + 1, sizeof(char *));
2070
2071         if (rec_argv == NULL)
2072                 return -ENOMEM;
2073
2074         j = 0;
2075         for (i = 0; i < ARRAY_SIZE(record_args); i++)
2076                 rec_argv[j++] = record_args[i];
2077
2078         if (trace->trace_syscalls) {
2079                 for (i = 0; i < sc_args_nr; i++)
2080                         rec_argv[j++] = sc_args[i];
2081
2082                 /* event string may be different for older kernels - e.g., RHEL6 */
2083                 if (is_valid_tracepoint("raw_syscalls:sys_enter"))
2084                         rec_argv[j++] = "raw_syscalls:sys_enter,raw_syscalls:sys_exit";
2085                 else if (is_valid_tracepoint("syscalls:sys_enter"))
2086                         rec_argv[j++] = "syscalls:sys_enter,syscalls:sys_exit";
2087                 else {
2088                         pr_err("Neither raw_syscalls nor syscalls events exist.\n");
2089                         free(rec_argv);
2090                         return -1;
2091                 }
2092         }
2093
2094         if (trace->trace_pgfaults & TRACE_PFMAJ)
2095                 for (i = 0; i < majpf_args_nr; i++)
2096                         rec_argv[j++] = majpf_args[i];
2097
2098         if (trace->trace_pgfaults & TRACE_PFMIN)
2099                 for (i = 0; i < minpf_args_nr; i++)
2100                         rec_argv[j++] = minpf_args[i];
2101
2102         for (i = 0; i < (unsigned int)argc; i++)
2103                 rec_argv[j++] = argv[i];
2104
2105         return cmd_record(j, rec_argv);
2106 }
2107
2108 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp);
2109
2110 static bool perf_evlist__add_vfs_getname(struct perf_evlist *evlist)
2111 {
2112         bool found = false;
2113         struct perf_evsel *evsel, *tmp;
2114         struct parse_events_error err = { .idx = 0, };
2115         int ret = parse_events(evlist, "probe:vfs_getname*", &err);
2116
2117         if (ret)
2118                 return false;
2119
2120         evlist__for_each_entry_safe(evlist, evsel, tmp) {
2121                 if (!strstarts(perf_evsel__name(evsel), "probe:vfs_getname"))
2122                         continue;
2123
2124                 if (perf_evsel__field(evsel, "pathname")) {
2125                         evsel->handler = trace__vfs_getname;
2126                         found = true;
2127                         continue;
2128                 }
2129
2130                 list_del_init(&evsel->node);
2131                 evsel->evlist = NULL;
2132                 perf_evsel__delete(evsel);
2133         }
2134
2135         return found;
2136 }
2137
2138 static struct perf_evsel *perf_evsel__new_pgfault(u64 config)
2139 {
2140         struct perf_evsel *evsel;
2141         struct perf_event_attr attr = {
2142                 .type = PERF_TYPE_SOFTWARE,
2143                 .mmap_data = 1,
2144         };
2145
2146         attr.config = config;
2147         attr.sample_period = 1;
2148
2149         event_attr_init(&attr);
2150
2151         evsel = perf_evsel__new(&attr);
2152         if (evsel)
2153                 evsel->handler = trace__pgfault;
2154
2155         return evsel;
2156 }
2157
2158 static void trace__handle_event(struct trace *trace, union perf_event *event, struct perf_sample *sample)
2159 {
2160         const u32 type = event->header.type;
2161         struct perf_evsel *evsel;
2162
2163         if (type != PERF_RECORD_SAMPLE) {
2164                 trace__process_event(trace, trace->host, event, sample);
2165                 return;
2166         }
2167
2168         evsel = perf_evlist__id2evsel(trace->evlist, sample->id);
2169         if (evsel == NULL) {
2170                 fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample->id);
2171                 return;
2172         }
2173
2174         trace__set_base_time(trace, evsel, sample);
2175
2176         if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
2177             sample->raw_data == NULL) {
2178                 fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
2179                        perf_evsel__name(evsel), sample->tid,
2180                        sample->cpu, sample->raw_size);
2181         } else {
2182                 tracepoint_handler handler = evsel->handler;
2183                 handler(trace, evsel, event, sample);
2184         }
2185 }
2186
2187 static int trace__add_syscall_newtp(struct trace *trace)
2188 {
2189         int ret = -1;
2190         struct perf_evlist *evlist = trace->evlist;
2191         struct perf_evsel *sys_enter, *sys_exit;
2192
2193         sys_enter = perf_evsel__syscall_newtp("sys_enter", trace__sys_enter);
2194         if (sys_enter == NULL)
2195                 goto out;
2196
2197         if (perf_evsel__init_sc_tp_ptr_field(sys_enter, args))
2198                 goto out_delete_sys_enter;
2199
2200         sys_exit = perf_evsel__syscall_newtp("sys_exit", trace__sys_exit);
2201         if (sys_exit == NULL)
2202                 goto out_delete_sys_enter;
2203
2204         if (perf_evsel__init_sc_tp_uint_field(sys_exit, ret))
2205                 goto out_delete_sys_exit;
2206
2207         perf_evlist__add(evlist, sys_enter);
2208         perf_evlist__add(evlist, sys_exit);
2209
2210         if (callchain_param.enabled && !trace->kernel_syscallchains) {
2211                 /*
2212                  * We're interested only in the user space callchain
2213                  * leading to the syscall, allow overriding that for
2214                  * debugging reasons using --kernel_syscall_callchains
2215                  */
2216                 sys_exit->attr.exclude_callchain_kernel = 1;
2217         }
2218
2219         trace->syscalls.events.sys_enter = sys_enter;
2220         trace->syscalls.events.sys_exit  = sys_exit;
2221
2222         ret = 0;
2223 out:
2224         return ret;
2225
2226 out_delete_sys_exit:
2227         perf_evsel__delete_priv(sys_exit);
2228 out_delete_sys_enter:
2229         perf_evsel__delete_priv(sys_enter);
2230         goto out;
2231 }
2232
2233 static int trace__set_ev_qualifier_filter(struct trace *trace)
2234 {
2235         int err = -1;
2236         struct perf_evsel *sys_exit;
2237         char *filter = asprintf_expr_inout_ints("id", !trace->not_ev_qualifier,
2238                                                 trace->ev_qualifier_ids.nr,
2239                                                 trace->ev_qualifier_ids.entries);
2240
2241         if (filter == NULL)
2242                 goto out_enomem;
2243
2244         if (!perf_evsel__append_tp_filter(trace->syscalls.events.sys_enter,
2245                                           filter)) {
2246                 sys_exit = trace->syscalls.events.sys_exit;
2247                 err = perf_evsel__append_tp_filter(sys_exit, filter);
2248         }
2249
2250         free(filter);
2251 out:
2252         return err;
2253 out_enomem:
2254         errno = ENOMEM;
2255         goto out;
2256 }
2257
2258 static int trace__set_filter_loop_pids(struct trace *trace)
2259 {
2260         unsigned int nr = 1;
2261         pid_t pids[32] = {
2262                 getpid(),
2263         };
2264         struct thread *thread = machine__find_thread(trace->host, pids[0], pids[0]);
2265
2266         while (thread && nr < ARRAY_SIZE(pids)) {
2267                 struct thread *parent = machine__find_thread(trace->host, thread->ppid, thread->ppid);
2268
2269                 if (parent == NULL)
2270                         break;
2271
2272                 if (!strcmp(thread__comm_str(parent), "sshd")) {
2273                         pids[nr++] = parent->tid;
2274                         break;
2275                 }
2276                 thread = parent;
2277         }
2278
2279         return perf_evlist__set_filter_pids(trace->evlist, nr, pids);
2280 }
2281
2282 static int trace__run(struct trace *trace, int argc, const char **argv)
2283 {
2284         struct perf_evlist *evlist = trace->evlist;
2285         struct perf_evsel *evsel, *pgfault_maj = NULL, *pgfault_min = NULL;
2286         int err = -1, i;
2287         unsigned long before;
2288         const bool forks = argc > 0;
2289         bool draining = false;
2290
2291         trace->live = true;
2292
2293         if (trace->trace_syscalls && trace__add_syscall_newtp(trace))
2294                 goto out_error_raw_syscalls;
2295
2296         if (trace->trace_syscalls)
2297                 trace->vfs_getname = perf_evlist__add_vfs_getname(evlist);
2298
2299         if ((trace->trace_pgfaults & TRACE_PFMAJ)) {
2300                 pgfault_maj = perf_evsel__new_pgfault(PERF_COUNT_SW_PAGE_FAULTS_MAJ);
2301                 if (pgfault_maj == NULL)
2302                         goto out_error_mem;
2303                 perf_evlist__add(evlist, pgfault_maj);
2304         }
2305
2306         if ((trace->trace_pgfaults & TRACE_PFMIN)) {
2307                 pgfault_min = perf_evsel__new_pgfault(PERF_COUNT_SW_PAGE_FAULTS_MIN);
2308                 if (pgfault_min == NULL)
2309                         goto out_error_mem;
2310                 perf_evlist__add(evlist, pgfault_min);
2311         }
2312
2313         if (trace->sched &&
2314             perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
2315                                    trace__sched_stat_runtime))
2316                 goto out_error_sched_stat_runtime;
2317
2318         err = perf_evlist__create_maps(evlist, &trace->opts.target);
2319         if (err < 0) {
2320                 fprintf(trace->output, "Problems parsing the target to trace, check your options!\n");
2321                 goto out_delete_evlist;
2322         }
2323
2324         err = trace__symbols_init(trace, evlist);
2325         if (err < 0) {
2326                 fprintf(trace->output, "Problems initializing symbol libraries!\n");
2327                 goto out_delete_evlist;
2328         }
2329
2330         perf_evlist__config(evlist, &trace->opts, NULL);
2331
2332         if (callchain_param.enabled) {
2333                 bool use_identifier = false;
2334
2335                 if (trace->syscalls.events.sys_exit) {
2336                         perf_evsel__config_callchain(trace->syscalls.events.sys_exit,
2337                                                      &trace->opts, &callchain_param);
2338                         use_identifier = true;
2339                 }
2340
2341                 if (pgfault_maj) {
2342                         perf_evsel__config_callchain(pgfault_maj, &trace->opts, &callchain_param);
2343                         use_identifier = true;
2344                 }
2345
2346                 if (pgfault_min) {
2347                         perf_evsel__config_callchain(pgfault_min, &trace->opts, &callchain_param);
2348                         use_identifier = true;
2349                 }
2350
2351                 if (use_identifier) {
2352                        /*
2353                         * Now we have evsels with different sample_ids, use
2354                         * PERF_SAMPLE_IDENTIFIER to map from sample to evsel
2355                         * from a fixed position in each ring buffer record.
2356                         *
2357                         * As of this the changeset introducing this comment, this
2358                         * isn't strictly needed, as the fields that can come before
2359                         * PERF_SAMPLE_ID are all used, but we'll probably disable
2360                         * some of those for things like copying the payload of
2361                         * pointer syscall arguments, and for vfs_getname we don't
2362                         * need PERF_SAMPLE_ADDR and PERF_SAMPLE_IP, so do this
2363                         * here as a warning we need to use PERF_SAMPLE_IDENTIFIER.
2364                         */
2365                         perf_evlist__set_sample_bit(evlist, IDENTIFIER);
2366                         perf_evlist__reset_sample_bit(evlist, ID);
2367                 }
2368         }
2369
2370         signal(SIGCHLD, sig_handler);
2371         signal(SIGINT, sig_handler);
2372
2373         if (forks) {
2374                 err = perf_evlist__prepare_workload(evlist, &trace->opts.target,
2375                                                     argv, false, NULL);
2376                 if (err < 0) {
2377                         fprintf(trace->output, "Couldn't run the workload!\n");
2378                         goto out_delete_evlist;
2379                 }
2380         }
2381
2382         err = perf_evlist__open(evlist);
2383         if (err < 0)
2384                 goto out_error_open;
2385
2386         err = bpf__apply_obj_config();
2387         if (err) {
2388                 char errbuf[BUFSIZ];
2389
2390                 bpf__strerror_apply_obj_config(err, errbuf, sizeof(errbuf));
2391                 pr_err("ERROR: Apply config to BPF failed: %s\n",
2392                          errbuf);
2393                 goto out_error_open;
2394         }
2395
2396         /*
2397          * Better not use !target__has_task() here because we need to cover the
2398          * case where no threads were specified in the command line, but a
2399          * workload was, and in that case we will fill in the thread_map when
2400          * we fork the workload in perf_evlist__prepare_workload.
2401          */
2402         if (trace->filter_pids.nr > 0)
2403                 err = perf_evlist__set_filter_pids(evlist, trace->filter_pids.nr, trace->filter_pids.entries);
2404         else if (thread_map__pid(evlist->threads, 0) == -1)
2405                 err = trace__set_filter_loop_pids(trace);
2406
2407         if (err < 0)
2408                 goto out_error_mem;
2409
2410         if (trace->ev_qualifier_ids.nr > 0) {
2411                 err = trace__set_ev_qualifier_filter(trace);
2412                 if (err < 0)
2413                         goto out_errno;
2414
2415                 pr_debug("event qualifier tracepoint filter: %s\n",
2416                          trace->syscalls.events.sys_exit->filter);
2417         }
2418
2419         err = perf_evlist__apply_filters(evlist, &evsel);
2420         if (err < 0)
2421                 goto out_error_apply_filters;
2422
2423         err = perf_evlist__mmap(evlist, trace->opts.mmap_pages, false);
2424         if (err < 0)
2425                 goto out_error_mmap;
2426
2427         if (!target__none(&trace->opts.target) && !trace->opts.initial_delay)
2428                 perf_evlist__enable(evlist);
2429
2430         if (forks)
2431                 perf_evlist__start_workload(evlist);
2432
2433         if (trace->opts.initial_delay) {
2434                 usleep(trace->opts.initial_delay * 1000);
2435                 perf_evlist__enable(evlist);
2436         }
2437
2438         trace->multiple_threads = thread_map__pid(evlist->threads, 0) == -1 ||
2439                                   evlist->threads->nr > 1 ||
2440                                   perf_evlist__first(evlist)->attr.inherit;
2441 again:
2442         before = trace->nr_events;
2443
2444         for (i = 0; i < evlist->nr_mmaps; i++) {
2445                 union perf_event *event;
2446
2447                 while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
2448                         struct perf_sample sample;
2449
2450                         ++trace->nr_events;
2451
2452                         err = perf_evlist__parse_sample(evlist, event, &sample);
2453                         if (err) {
2454                                 fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);
2455                                 goto next_event;
2456                         }
2457
2458                         trace__handle_event(trace, event, &sample);
2459 next_event:
2460                         perf_evlist__mmap_consume(evlist, i);
2461
2462                         if (interrupted)
2463                                 goto out_disable;
2464
2465                         if (done && !draining) {
2466                                 perf_evlist__disable(evlist);
2467                                 draining = true;
2468                         }
2469                 }
2470         }
2471
2472         if (trace->nr_events == before) {
2473                 int timeout = done ? 100 : -1;
2474
2475                 if (!draining && perf_evlist__poll(evlist, timeout) > 0) {
2476                         if (perf_evlist__filter_pollfd(evlist, POLLERR | POLLHUP) == 0)
2477                                 draining = true;
2478
2479                         goto again;
2480                 }
2481         } else {
2482                 goto again;
2483         }
2484
2485 out_disable:
2486         thread__zput(trace->current);
2487
2488         perf_evlist__disable(evlist);
2489
2490         if (!err) {
2491                 if (trace->summary)
2492                         trace__fprintf_thread_summary(trace, trace->output);
2493
2494                 if (trace->show_tool_stats) {
2495                         fprintf(trace->output, "Stats:\n "
2496                                                " vfs_getname : %" PRIu64 "\n"
2497                                                " proc_getname: %" PRIu64 "\n",
2498                                 trace->stats.vfs_getname,
2499                                 trace->stats.proc_getname);
2500                 }
2501         }
2502
2503 out_delete_evlist:
2504         trace__symbols__exit(trace);
2505
2506         perf_evlist__delete(evlist);
2507         trace->evlist = NULL;
2508         trace->live = false;
2509         return err;
2510 {
2511         char errbuf[BUFSIZ];
2512
2513 out_error_sched_stat_runtime:
2514         tracing_path__strerror_open_tp(errno, errbuf, sizeof(errbuf), "sched", "sched_stat_runtime");
2515         goto out_error;
2516
2517 out_error_raw_syscalls:
2518         tracing_path__strerror_open_tp(errno, errbuf, sizeof(errbuf), "raw_syscalls", "sys_(enter|exit)");
2519         goto out_error;
2520
2521 out_error_mmap:
2522         perf_evlist__strerror_mmap(evlist, errno, errbuf, sizeof(errbuf));
2523         goto out_error;
2524
2525 out_error_open:
2526         perf_evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
2527
2528 out_error:
2529         fprintf(trace->output, "%s\n", errbuf);
2530         goto out_delete_evlist;
2531
2532 out_error_apply_filters:
2533         fprintf(trace->output,
2534                 "Failed to set filter \"%s\" on event %s with %d (%s)\n",
2535                 evsel->filter, perf_evsel__name(evsel), errno,
2536                 str_error_r(errno, errbuf, sizeof(errbuf)));
2537         goto out_delete_evlist;
2538 }
2539 out_error_mem:
2540         fprintf(trace->output, "Not enough memory to run!\n");
2541         goto out_delete_evlist;
2542
2543 out_errno:
2544         fprintf(trace->output, "errno=%d,%s\n", errno, strerror(errno));
2545         goto out_delete_evlist;
2546 }
2547
2548 static int trace__replay(struct trace *trace)
2549 {
2550         const struct perf_evsel_str_handler handlers[] = {
2551                 { "probe:vfs_getname",       trace__vfs_getname, },
2552         };
2553         struct perf_data_file file = {
2554                 .path  = input_name,
2555                 .mode  = PERF_DATA_MODE_READ,
2556                 .force = trace->force,
2557         };
2558         struct perf_session *session;
2559         struct perf_evsel *evsel;
2560         int err = -1;
2561
2562         trace->tool.sample        = trace__process_sample;
2563         trace->tool.mmap          = perf_event__process_mmap;
2564         trace->tool.mmap2         = perf_event__process_mmap2;
2565         trace->tool.comm          = perf_event__process_comm;
2566         trace->tool.exit          = perf_event__process_exit;
2567         trace->tool.fork          = perf_event__process_fork;
2568         trace->tool.attr          = perf_event__process_attr;
2569         trace->tool.tracing_data  = perf_event__process_tracing_data;
2570         trace->tool.build_id      = perf_event__process_build_id;
2571         trace->tool.namespaces    = perf_event__process_namespaces;
2572
2573         trace->tool.ordered_events = true;
2574         trace->tool.ordering_requires_timestamps = true;
2575
2576         /* add tid to output */
2577         trace->multiple_threads = true;
2578
2579         session = perf_session__new(&file, false, &trace->tool);
2580         if (session == NULL)
2581                 return -1;
2582
2583         if (trace->opts.target.pid)
2584                 symbol_conf.pid_list_str = strdup(trace->opts.target.pid);
2585
2586         if (trace->opts.target.tid)
2587                 symbol_conf.tid_list_str = strdup(trace->opts.target.tid);
2588
2589         if (symbol__init(&session->header.env) < 0)
2590                 goto out;
2591
2592         trace->host = &session->machines.host;
2593
2594         err = perf_session__set_tracepoints_handlers(session, handlers);
2595         if (err)
2596                 goto out;
2597
2598         evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2599                                                      "raw_syscalls:sys_enter");
2600         /* older kernels have syscalls tp versus raw_syscalls */
2601         if (evsel == NULL)
2602                 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2603                                                              "syscalls:sys_enter");
2604
2605         if (evsel &&
2606             (perf_evsel__init_syscall_tp(evsel, trace__sys_enter) < 0 ||
2607             perf_evsel__init_sc_tp_ptr_field(evsel, args))) {
2608                 pr_err("Error during initialize raw_syscalls:sys_enter event\n");
2609                 goto out;
2610         }
2611
2612         evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2613                                                      "raw_syscalls:sys_exit");
2614         if (evsel == NULL)
2615                 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2616                                                              "syscalls:sys_exit");
2617         if (evsel &&
2618             (perf_evsel__init_syscall_tp(evsel, trace__sys_exit) < 0 ||
2619             perf_evsel__init_sc_tp_uint_field(evsel, ret))) {
2620                 pr_err("Error during initialize raw_syscalls:sys_exit event\n");
2621                 goto out;
2622         }
2623
2624         evlist__for_each_entry(session->evlist, evsel) {
2625                 if (evsel->attr.type == PERF_TYPE_SOFTWARE &&
2626                     (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ||
2627                      evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MIN ||
2628                      evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS))
2629                         evsel->handler = trace__pgfault;
2630         }
2631
2632         setup_pager();
2633
2634         err = perf_session__process_events(session);
2635         if (err)
2636                 pr_err("Failed to process events, error %d", err);
2637
2638         else if (trace->summary)
2639                 trace__fprintf_thread_summary(trace, trace->output);
2640
2641 out:
2642         perf_session__delete(session);
2643
2644         return err;
2645 }
2646
2647 static size_t trace__fprintf_threads_header(FILE *fp)
2648 {
2649         size_t printed;
2650
2651         printed  = fprintf(fp, "\n Summary of events:\n\n");
2652
2653         return printed;
2654 }
2655
2656 DEFINE_RESORT_RB(syscall_stats, a->msecs > b->msecs,
2657         struct stats    *stats;
2658         double          msecs;
2659         int             syscall;
2660 )
2661 {
2662         struct int_node *source = rb_entry(nd, struct int_node, rb_node);
2663         struct stats *stats = source->priv;
2664
2665         entry->syscall = source->i;
2666         entry->stats   = stats;
2667         entry->msecs   = stats ? (u64)stats->n * (avg_stats(stats) / NSEC_PER_MSEC) : 0;
2668 }
2669
2670 static size_t thread__dump_stats(struct thread_trace *ttrace,
2671                                  struct trace *trace, FILE *fp)
2672 {
2673         size_t printed = 0;
2674         struct syscall *sc;
2675         struct rb_node *nd;
2676         DECLARE_RESORT_RB_INTLIST(syscall_stats, ttrace->syscall_stats);
2677
2678         if (syscall_stats == NULL)
2679                 return 0;
2680
2681         printed += fprintf(fp, "\n");
2682
2683         printed += fprintf(fp, "   syscall            calls    total       min       avg       max      stddev\n");
2684         printed += fprintf(fp, "                               (msec)    (msec)    (msec)    (msec)        (%%)\n");
2685         printed += fprintf(fp, "   --------------- -------- --------- --------- --------- ---------     ------\n");
2686
2687         resort_rb__for_each_entry(nd, syscall_stats) {
2688                 struct stats *stats = syscall_stats_entry->stats;
2689                 if (stats) {
2690                         double min = (double)(stats->min) / NSEC_PER_MSEC;
2691                         double max = (double)(stats->max) / NSEC_PER_MSEC;
2692                         double avg = avg_stats(stats);
2693                         double pct;
2694                         u64 n = (u64) stats->n;
2695
2696                         pct = avg ? 100.0 * stddev_stats(stats)/avg : 0.0;
2697                         avg /= NSEC_PER_MSEC;
2698
2699                         sc = &trace->syscalls.table[syscall_stats_entry->syscall];
2700                         printed += fprintf(fp, "   %-15s", sc->name);
2701                         printed += fprintf(fp, " %8" PRIu64 " %9.3f %9.3f %9.3f",
2702                                            n, syscall_stats_entry->msecs, min, avg);
2703                         printed += fprintf(fp, " %9.3f %9.2f%%\n", max, pct);
2704                 }
2705         }
2706
2707         resort_rb__delete(syscall_stats);
2708         printed += fprintf(fp, "\n\n");
2709
2710         return printed;
2711 }
2712
2713 static size_t trace__fprintf_thread(FILE *fp, struct thread *thread, struct trace *trace)
2714 {
2715         size_t printed = 0;
2716         struct thread_trace *ttrace = thread__priv(thread);
2717         double ratio;
2718
2719         if (ttrace == NULL)
2720                 return 0;
2721
2722         ratio = (double)ttrace->nr_events / trace->nr_events * 100.0;
2723
2724         printed += fprintf(fp, " %s (%d), ", thread__comm_str(thread), thread->tid);
2725         printed += fprintf(fp, "%lu events, ", ttrace->nr_events);
2726         printed += fprintf(fp, "%.1f%%", ratio);
2727         if (ttrace->pfmaj)
2728                 printed += fprintf(fp, ", %lu majfaults", ttrace->pfmaj);
2729         if (ttrace->pfmin)
2730                 printed += fprintf(fp, ", %lu minfaults", ttrace->pfmin);
2731         if (trace->sched)
2732                 printed += fprintf(fp, ", %.3f msec\n", ttrace->runtime_ms);
2733         else if (fputc('\n', fp) != EOF)
2734                 ++printed;
2735
2736         printed += thread__dump_stats(ttrace, trace, fp);
2737
2738         return printed;
2739 }
2740
2741 static unsigned long thread__nr_events(struct thread_trace *ttrace)
2742 {
2743         return ttrace ? ttrace->nr_events : 0;
2744 }
2745
2746 DEFINE_RESORT_RB(threads, (thread__nr_events(a->thread->priv) < thread__nr_events(b->thread->priv)),
2747         struct thread *thread;
2748 )
2749 {
2750         entry->thread = rb_entry(nd, struct thread, rb_node);
2751 }
2752
2753 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
2754 {
2755         DECLARE_RESORT_RB_MACHINE_THREADS(threads, trace->host);
2756         size_t printed = trace__fprintf_threads_header(fp);
2757         struct rb_node *nd;
2758
2759         if (threads == NULL) {
2760                 fprintf(fp, "%s", "Error sorting output by nr_events!\n");
2761                 return 0;
2762         }
2763
2764         resort_rb__for_each_entry(nd, threads)
2765                 printed += trace__fprintf_thread(fp, threads_entry->thread, trace);
2766
2767         resort_rb__delete(threads);
2768
2769         return printed;
2770 }
2771
2772 static int trace__set_duration(const struct option *opt, const char *str,
2773                                int unset __maybe_unused)
2774 {
2775         struct trace *trace = opt->value;
2776
2777         trace->duration_filter = atof(str);
2778         return 0;
2779 }
2780
2781 static int trace__set_filter_pids(const struct option *opt, const char *str,
2782                                   int unset __maybe_unused)
2783 {
2784         int ret = -1;
2785         size_t i;
2786         struct trace *trace = opt->value;
2787         /*
2788          * FIXME: introduce a intarray class, plain parse csv and create a
2789          * { int nr, int entries[] } struct...
2790          */
2791         struct intlist *list = intlist__new(str);
2792
2793         if (list == NULL)
2794                 return -1;
2795
2796         i = trace->filter_pids.nr = intlist__nr_entries(list) + 1;
2797         trace->filter_pids.entries = calloc(i, sizeof(pid_t));
2798
2799         if (trace->filter_pids.entries == NULL)
2800                 goto out;
2801
2802         trace->filter_pids.entries[0] = getpid();
2803
2804         for (i = 1; i < trace->filter_pids.nr; ++i)
2805                 trace->filter_pids.entries[i] = intlist__entry(list, i - 1)->i;
2806
2807         intlist__delete(list);
2808         ret = 0;
2809 out:
2810         return ret;
2811 }
2812
2813 static int trace__open_output(struct trace *trace, const char *filename)
2814 {
2815         struct stat st;
2816
2817         if (!stat(filename, &st) && st.st_size) {
2818                 char oldname[PATH_MAX];
2819
2820                 scnprintf(oldname, sizeof(oldname), "%s.old", filename);
2821                 unlink(oldname);
2822                 rename(filename, oldname);
2823         }
2824
2825         trace->output = fopen(filename, "w");
2826
2827         return trace->output == NULL ? -errno : 0;
2828 }
2829
2830 static int parse_pagefaults(const struct option *opt, const char *str,
2831                             int unset __maybe_unused)
2832 {
2833         int *trace_pgfaults = opt->value;
2834
2835         if (strcmp(str, "all") == 0)
2836                 *trace_pgfaults |= TRACE_PFMAJ | TRACE_PFMIN;
2837         else if (strcmp(str, "maj") == 0)
2838                 *trace_pgfaults |= TRACE_PFMAJ;
2839         else if (strcmp(str, "min") == 0)
2840                 *trace_pgfaults |= TRACE_PFMIN;
2841         else
2842                 return -1;
2843
2844         return 0;
2845 }
2846
2847 static void evlist__set_evsel_handler(struct perf_evlist *evlist, void *handler)
2848 {
2849         struct perf_evsel *evsel;
2850
2851         evlist__for_each_entry(evlist, evsel)
2852                 evsel->handler = handler;
2853 }
2854
2855 /*
2856  * XXX: Hackish, just splitting the combined -e+--event (syscalls
2857  * (raw_syscalls:{sys_{enter,exit}} + events (tracepoints, HW, SW, etc) to use
2858  * existing facilities unchanged (trace->ev_qualifier + parse_options()).
2859  *
2860  * It'd be better to introduce a parse_options() variant that would return a
2861  * list with the terms it didn't match to an event...
2862  */
2863 static int trace__parse_events_option(const struct option *opt, const char *str,
2864                                       int unset __maybe_unused)
2865 {
2866         struct trace *trace = (struct trace *)opt->value;
2867         const char *s = str;
2868         char *sep = NULL, *lists[2] = { NULL, NULL, };
2869         int len = strlen(str) + 1, err = -1, list, idx;
2870         char *strace_groups_dir = system_path(STRACE_GROUPS_DIR);
2871         char group_name[PATH_MAX];
2872
2873         if (strace_groups_dir == NULL)
2874                 return -1;
2875
2876         if (*s == '!') {
2877                 ++s;
2878                 trace->not_ev_qualifier = true;
2879         }
2880
2881         while (1) {
2882                 if ((sep = strchr(s, ',')) != NULL)
2883                         *sep = '\0';
2884
2885                 list = 0;
2886                 if (syscalltbl__id(trace->sctbl, s) >= 0 ||
2887                     syscalltbl__strglobmatch_first(trace->sctbl, s, &idx) >= 0) {
2888                         list = 1;
2889                 } else {
2890                         path__join(group_name, sizeof(group_name), strace_groups_dir, s);
2891                         if (access(group_name, R_OK) == 0)
2892                                 list = 1;
2893                 }
2894
2895                 if (lists[list]) {
2896                         sprintf(lists[list] + strlen(lists[list]), ",%s", s);
2897                 } else {
2898                         lists[list] = malloc(len);
2899                         if (lists[list] == NULL)
2900                                 goto out;
2901                         strcpy(lists[list], s);
2902                 }
2903
2904                 if (!sep)
2905                         break;
2906
2907                 *sep = ',';
2908                 s = sep + 1;
2909         }
2910
2911         if (lists[1] != NULL) {
2912                 struct strlist_config slist_config = {
2913                         .dirname = strace_groups_dir,
2914                 };
2915
2916                 trace->ev_qualifier = strlist__new(lists[1], &slist_config);
2917                 if (trace->ev_qualifier == NULL) {
2918                         fputs("Not enough memory to parse event qualifier", trace->output);
2919                         goto out;
2920                 }
2921
2922                 if (trace__validate_ev_qualifier(trace))
2923                         goto out;
2924         }
2925
2926         err = 0;
2927
2928         if (lists[0]) {
2929                 struct option o = OPT_CALLBACK('e', "event", &trace->evlist, "event",
2930                                                "event selector. use 'perf list' to list available events",
2931                                                parse_events_option);
2932                 err = parse_events_option(&o, lists[0], 0);
2933         }
2934 out:
2935         if (sep)
2936                 *sep = ',';
2937
2938         return err;
2939 }
2940
2941 int cmd_trace(int argc, const char **argv)
2942 {
2943         const char *trace_usage[] = {
2944                 "perf trace [<options>] [<command>]",
2945                 "perf trace [<options>] -- <command> [<options>]",
2946                 "perf trace record [<options>] [<command>]",
2947                 "perf trace record [<options>] -- <command> [<options>]",
2948                 NULL
2949         };
2950         struct trace trace = {
2951                 .syscalls = {
2952                         . max = -1,
2953                 },
2954                 .opts = {
2955                         .target = {
2956                                 .uid       = UINT_MAX,
2957                                 .uses_mmap = true,
2958                         },
2959                         .user_freq     = UINT_MAX,
2960                         .user_interval = ULLONG_MAX,
2961                         .no_buffering  = true,
2962                         .mmap_pages    = UINT_MAX,
2963                         .proc_map_timeout  = 500,
2964                 },
2965                 .output = stderr,
2966                 .show_comm = true,
2967                 .trace_syscalls = true,
2968                 .kernel_syscallchains = false,
2969                 .max_stack = UINT_MAX,
2970         };
2971         const char *output_name = NULL;
2972         const struct option trace_options[] = {
2973         OPT_CALLBACK('e', "event", &trace, "event",
2974                      "event/syscall selector. use 'perf list' to list available events",
2975                      trace__parse_events_option),
2976         OPT_BOOLEAN(0, "comm", &trace.show_comm,
2977                     "show the thread COMM next to its id"),
2978         OPT_BOOLEAN(0, "tool_stats", &trace.show_tool_stats, "show tool stats"),
2979         OPT_CALLBACK(0, "expr", &trace, "expr", "list of syscalls/events to trace",
2980                      trace__parse_events_option),
2981         OPT_STRING('o', "output", &output_name, "file", "output file name"),
2982         OPT_STRING('i', "input", &input_name, "file", "Analyze events in file"),
2983         OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
2984                     "trace events on existing process id"),
2985         OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
2986                     "trace events on existing thread id"),
2987         OPT_CALLBACK(0, "filter-pids", &trace, "CSV list of pids",
2988                      "pids to filter (by the kernel)", trace__set_filter_pids),
2989         OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
2990                     "system-wide collection from all CPUs"),
2991         OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
2992                     "list of cpus to monitor"),
2993         OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
2994                     "child tasks do not inherit counters"),
2995         OPT_CALLBACK('m', "mmap-pages", &trace.opts.mmap_pages, "pages",
2996                      "number of mmap data pages",
2997                      perf_evlist__parse_mmap_pages),
2998         OPT_STRING('u', "uid", &trace.opts.target.uid_str, "user",
2999                    "user to profile"),
3000         OPT_CALLBACK(0, "duration", &trace, "float",
3001                      "show only events with duration > N.M ms",
3002                      trace__set_duration),
3003         OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),
3004         OPT_INCR('v', "verbose", &verbose, "be more verbose"),
3005         OPT_BOOLEAN('T', "time", &trace.full_time,
3006                     "Show full timestamp, not time relative to first start"),
3007         OPT_BOOLEAN('s', "summary", &trace.summary_only,
3008                     "Show only syscall summary with statistics"),
3009         OPT_BOOLEAN('S', "with-summary", &trace.summary,
3010                     "Show all syscalls and summary with statistics"),
3011         OPT_CALLBACK_DEFAULT('F', "pf", &trace.trace_pgfaults, "all|maj|min",
3012                      "Trace pagefaults", parse_pagefaults, "maj"),
3013         OPT_BOOLEAN(0, "syscalls", &trace.trace_syscalls, "Trace syscalls"),
3014         OPT_BOOLEAN('f', "force", &trace.force, "don't complain, do it"),
3015         OPT_CALLBACK(0, "call-graph", &trace.opts,
3016                      "record_mode[,record_size]", record_callchain_help,
3017                      &record_parse_callchain_opt),
3018         OPT_BOOLEAN(0, "kernel-syscall-graph", &trace.kernel_syscallchains,
3019                     "Show the kernel callchains on the syscall exit path"),
3020         OPT_UINTEGER(0, "min-stack", &trace.min_stack,
3021                      "Set the minimum stack depth when parsing the callchain, "
3022                      "anything below the specified depth will be ignored."),
3023         OPT_UINTEGER(0, "max-stack", &trace.max_stack,
3024                      "Set the maximum stack depth when parsing the callchain, "
3025                      "anything beyond the specified depth will be ignored. "
3026                      "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)),
3027         OPT_UINTEGER(0, "proc-map-timeout", &trace.opts.proc_map_timeout,
3028                         "per thread proc mmap processing timeout in ms"),
3029         OPT_UINTEGER('D', "delay", &trace.opts.initial_delay,
3030                      "ms to wait before starting measurement after program "
3031                      "start"),
3032         OPT_END()
3033         };
3034         bool __maybe_unused max_stack_user_set = true;
3035         bool mmap_pages_user_set = true;
3036         const char * const trace_subcommands[] = { "record", NULL };
3037         int err;
3038         char bf[BUFSIZ];
3039
3040         signal(SIGSEGV, sighandler_dump_stack);
3041         signal(SIGFPE, sighandler_dump_stack);
3042
3043         trace.evlist = perf_evlist__new();
3044         trace.sctbl = syscalltbl__new();
3045
3046         if (trace.evlist == NULL || trace.sctbl == NULL) {
3047                 pr_err("Not enough memory to run!\n");
3048                 err = -ENOMEM;
3049                 goto out;
3050         }
3051
3052         argc = parse_options_subcommand(argc, argv, trace_options, trace_subcommands,
3053                                  trace_usage, PARSE_OPT_STOP_AT_NON_OPTION);
3054
3055         err = bpf__setup_stdout(trace.evlist);
3056         if (err) {
3057                 bpf__strerror_setup_stdout(trace.evlist, err, bf, sizeof(bf));
3058                 pr_err("ERROR: Setup BPF stdout failed: %s\n", bf);
3059                 goto out;
3060         }
3061
3062         err = -1;
3063
3064         if (trace.trace_pgfaults) {
3065                 trace.opts.sample_address = true;
3066                 trace.opts.sample_time = true;
3067         }
3068
3069         if (trace.opts.mmap_pages == UINT_MAX)
3070                 mmap_pages_user_set = false;
3071
3072         if (trace.max_stack == UINT_MAX) {
3073                 trace.max_stack = input_name ? PERF_MAX_STACK_DEPTH : sysctl_perf_event_max_stack;
3074                 max_stack_user_set = false;
3075         }
3076
3077 #ifdef HAVE_DWARF_UNWIND_SUPPORT
3078         if ((trace.min_stack || max_stack_user_set) && !callchain_param.enabled && trace.trace_syscalls)
3079                 record_opts__parse_callchain(&trace.opts, &callchain_param, "dwarf", false);
3080 #endif
3081
3082         if (callchain_param.enabled) {
3083                 if (!mmap_pages_user_set && geteuid() == 0)
3084                         trace.opts.mmap_pages = perf_event_mlock_kb_in_pages() * 4;
3085
3086                 symbol_conf.use_callchain = true;
3087         }
3088
3089         if (trace.evlist->nr_entries > 0)
3090                 evlist__set_evsel_handler(trace.evlist, trace__event_handler);
3091
3092         if ((argc >= 1) && (strcmp(argv[0], "record") == 0))
3093                 return trace__record(&trace, argc-1, &argv[1]);
3094
3095         /* summary_only implies summary option, but don't overwrite summary if set */
3096         if (trace.summary_only)
3097                 trace.summary = trace.summary_only;
3098
3099         if (!trace.trace_syscalls && !trace.trace_pgfaults &&
3100             trace.evlist->nr_entries == 0 /* Was --events used? */) {
3101                 pr_err("Please specify something to trace.\n");
3102                 return -1;
3103         }
3104
3105         if (!trace.trace_syscalls && trace.ev_qualifier) {
3106                 pr_err("The -e option can't be used with --no-syscalls.\n");
3107                 goto out;
3108         }
3109
3110         if (output_name != NULL) {
3111                 err = trace__open_output(&trace, output_name);
3112                 if (err < 0) {
3113                         perror("failed to create output file");
3114                         goto out;
3115                 }
3116         }
3117
3118         trace.open_id = syscalltbl__id(trace.sctbl, "open");
3119
3120         err = target__validate(&trace.opts.target);
3121         if (err) {
3122                 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
3123                 fprintf(trace.output, "%s", bf);
3124                 goto out_close;
3125         }
3126
3127         err = target__parse_uid(&trace.opts.target);
3128         if (err) {
3129                 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
3130                 fprintf(trace.output, "%s", bf);
3131                 goto out_close;
3132         }
3133
3134         if (!argc && target__none(&trace.opts.target))
3135                 trace.opts.target.system_wide = true;
3136
3137         if (input_name)
3138                 err = trace__replay(&trace);
3139         else
3140                 err = trace__run(&trace, argc, argv);
3141
3142 out_close:
3143         if (output_name != NULL)
3144                 fclose(trace.output);
3145 out:
3146         return err;
3147 }