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