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