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