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