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