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